3 La Programmation en Assembleur 3.1 Introduction (PDFDrive)

Informatique 3
Microordinateur
Programmation assembleur
Interface C / Assembleur
 2008 HESB-TI / Dr E. FIROUZI
Dernier changement : Août 2015

Auteur : Prof. Dr E. FIROUZI
Version : 5.3
Informatique 3 Avant propos
Avant-propos
Ce manuscrit est distribué aux étudiants du module « Informatique 3 » de la section Electricité et système de
communication de la Haute école spécialisée bernoise. Il est complété par des exercices, qui sont distribués en
supplément durant le cours, et un projet, qui est réalisé à la fin du semestre.
La première partie du manuscrit traite la structure d’un microordinateur. Cette partie comprend l’organisation de
la CPU et sa connexion avec les composants externes. La seconde partie du manuscrit introduit la
programmation en assembleur. Cette introduction s’effectue avec des exemples, qui se basent sur un
microcontrôleur RISC à 32 bits : le PXA270 de Intel. La dernière partie du manuscrit traite l’interface C –
assembleur, en se référant aux cours de C (modules informatiques 1 et 2).
Tous les exercices et le projet sont réalisés avec le kit de développement CARME, qui est introduit au deuxième
semestre.
Des informations supplémentaires sont mises à disposition sur le site: http://prof.hti.bfh.ch/fue1
A la fin de ce module, les étudiants sont en mesure de :

1) Concevoir un schéma hardware contenant un microcontrôleur, de la mémoire externe et des composants
périphériques
2) Réaliser un projet en C et assembleur
Un grand remerciement à G. KRUGER et R. WEBER pour leur aides apportées pour la définition de la version
en allemand du manuscrit ; ainsi qu’à M. MÜHLEMANN et E. STUCKI pour la mise en place de
l’environnement de développement.
Bienne, août 2015

E. FIROUZI
Version 3.1, juin 2008 Page I

Informatique 3 Table des matières
Table des matières

1 Architecture d’un microordinateur standard .................................................................................................... 1
1.1 Les catégories des ordinateurs................................................................................................................. 1
1.1.1 La classification selon Flynn ........................................................................................................... 1
1.1.2 La communication chez les ordinateurs MIMD .............................................................................. 2
1.2 Les architectures des microordinateurs ................................................................................................... 3
1.2.1 L’architecture de Von Neumann ..................................................................................................... 3
1.2.2 L’Architecture de Harvard .............................................................................................................. 4
1.3 La CPU.................................................................................................................................................... 4
1.4 Le système de bus ................................................................................................................................... 5
1.4.1 Les bus d’adresse, de données et de contrôle .................................................................................. 5
1.4.2 Le plan de mémoire ......................................................................................................................... 7
1.4.3 Le décodeur d’adresse ..................................................................................................................... 8
1.5 La mémoire ............................................................................................................................................. 9
1.5.1 Les technologies .............................................................................................................................. 9
1.5.2 L’organisation de la mémoire........................................................................................................ 10
1.5.3 Les architectures............................................................................................................................ 10
1.5.4 La documentation .......................................................................................................................... 12
1.6 La hiérarchie de la mémoire .................................................................................................................. 13
1.7 La MMU ............................................................................................................................................... 14
1.7.1 Les adresses physiques et virtuelles .............................................................................................. 14
1.7.2 Pages et trames, Tableau de pages ................................................................................................ 15
1.7.3 Les tampons auxiliaires de traduction ........................................................................................... 16
1.8 DMA ..................................................................................................................................................... 17
1.9 La périphérie ......................................................................................................................................... 18
1.9.1 Les amplificateurs de sortie........................................................................................................... 18
1.9.2 Digital Input / Output .................................................................................................................... 19
1.9.3 L’interface sérielle ........................................................................................................................ 20
1.9.4 Le timer ......................................................................................................................................... 25
1.9.5 Les convertisseurs A/D ................................................................................................................. 26
1.9.6 Les convertisseurs D/A ................................................................................................................. 26
1.10 Les types de processeur ......................................................................................................................... 27
1.10.1 Les microprocesseurs .................................................................................................................... 27
1.10.2 Les microcontrôleurs ..................................................................................................................... 27
1.10.3 Les DSP......................................................................................................................................... 27
1.10.4 CISC / RISC .................................................................................................................................. 27
1.11 Exemple de famille de microcontrôleur ................................................................................................ 27
1.12 Les critères pour le choix d'un microcontrôleur .................................................................................... 28
2 Le microcontrôleur STM32F407 ................................................................................................................... 30
2.1 L’architecture ARM .............................................................................................................................. 30
2.2 Le processeur Cortex-M4 ...................................................................................................................... 33
2.2.1 L’architecture du processeur Cortex-M4....................................................................................... 33
2.2.2 Le cœur d’exécution du Cortex-M4 .............................................................................................. 35
2.2.3 Le pipeline des instructions du Cortex-M4 ................................................................................... 36
2.3 Le microcontrôleur STM32F407xx ...................................................................................................... 36
2.3.1 Les propriétés du STM32F407xx .................................................................................................. 36
2.3.2 Le diagramme de bloc du microcontrôleur STM32F407xx .......................................................... 37
2.4 Les modes de fonctionnement et les niveaux de privilège .................................................................... 39
2.5 Le modèle des registres ......................................................................................................................... 39
2.5.1 Program Status Register (PSR) ..................................................................................................... 40
2.5.2 Les bits de condition ..................................................................................................................... 42
Version 3.1, juin 2008 Page II

2.5.3 Exception Mask Registers ............................................................................................................. 43

2.5.4 CONTROL-Register ....................................................................................................................... 44
2.6 Les modèles de mémoire et les formats de données.............................................................................. 45
2.7 Le plan de mémoire du STM32F407xx ................................................................................................ 46
2.8 Le plan de mémoire du CARME........................................................................................................... 48
2.9 Le schéma des pins................................................................................................................................ 49
2.10 Connexion des composants Flash et SDRAM....................................................................................... 50
3 La programmation en assembleur .................................................................................................................. 51
3.1 Introduction ........................................................................................................................................... 51
3.2 Les niveaux des langages de programmation ........................................................................................ 51
3.3 La structure d’un fichier en assembleur ................................................................................................ 52
3.4 La syntaxe assembleur .......................................................................................................................... 53
3.4.1 La structure d’une ligne assembleur .............................................................................................. 53
3.4.2 Les symboles ................................................................................................................................. 55
3.4.3 Les constantes ............................................................................................................................... 55
3.4.4 Les opérateurs et les opérandes ..................................................................................................... 57
3.5 L’environnement de développement ..................................................................................................... 58
3.5.1 L’éditeur ........................................................................................................................................ 58
3.5.2 L’assembler ................................................................................................................................... 59
3.5.3 Le compilateur .............................................................................................................................. 60
3.5.4 Le relieur / locateur ....................................................................................................................... 60
3.5.5 Le débuggeur................................................................................................................................. 61
3.5.6 La gestion du projet ....................................................................................................................... 61
4 Jeu d’instructions du Cortex-M4 .................................................................................................................... 62
4.1 Les instructions ..................................................................................................................................... 62
4.1.1 La syntaxe des instructions ARM ................................................................................................. 64
4.1.2 La syntaxe de la notation ............................................................................................................... 64
4.1.3 Exécution d’instruction conditionnelle.......................................................................................... 65
4.2 La vue d’ensemble du jeu d’instructions ............................................................................................... 67
4.3 Les transferts de données ...................................................................................................................... 67
4.3.1 Les instructions de transfert de données entre registres MOV et MVN ............................................ 68
4.3.2 Le décalage à barilier (Barrel Shifter) ........................................................................................... 68
4.3.3 Les instructions de chargement de données LDR et STR .............................................................. 70
4.3.4 Modes d’adressage pour les instructions de chargement et de stockage ....................................... 71
4.3.5 L’instruction SWP .......................................................................................................................... 73
4.3.6 Chargement et stockage multiple LDM et STM .............................................................................. 74
4.3.7 Les instructions de la pile LDM et STM .......................................................................................... 75
4.3.8 Les instructions de la pile PUSH et POP ....................................................................................... 76
4.3.9 Les instructions d’état MRS et MSR ............................................................................................... 76
4.4 Les instructions arithmétiques et logiques ............................................................................................ 78
4.4.1 L’arithmétique des entiers ............................................................................................................. 78
4.4.2 Les instructions logiques ............................................................................................................... 81
4.4.3 Les instructions de décalage et de rotation .................................................................................... 82
4.5 Les sauts de programme ........................................................................................................................ 83
4.5.1 Généralité ...................................................................................................................................... 83
4.5.2 Les sauts de programme inconditionnels ...................................................................................... 84
4.5.3 Les sauts de programmes conditionnels ........................................................................................ 85
4.6 Les autres instructions ARM ................................................................................................................. 87
4.6.1 L’instruction If-Then-Else (IT) .................................................................................................... 87
4.6.2 Les interruptions software SVC ..................................................................................................... 87
4.6.3 Les points d’arrêt BKPT ................................................................................................................ 88
4.6.4 Le comptage des zéros CLZ .......................................................................................................... 88
5 Les directives de l’assembleur ....................................................................................................................... 90
Version 3.1, juin 2008 Page III

5.1 Introduction ........................................................................................................................................... 90

5.2 Aperçu ................................................................................................................................................... 90
5.3 .arm, .thumb ..................................................................................................................................... 91
5.4 .global, .extern ........................................................................................................................... 92
5.5 .align.................................................................................................................................................. 92
5.5.1 .balign ....................................................................................................................................... 93
5.5.2 .p2align.................................................................................................................................... 94
5.6 .ascii, .asciz ................................................................................................................................ 95
5.7 .byte................................................................................................................................................... 95
5.7.1 .2byte, .hword ........................................................................................................................ 95
5.7.2 .word, .4byte .......................................................................................................................... 96
5.8 .space ................................................................................................................................................ 96
5.9 .include ........................................................................................................................................... 97
5.10 .equ, .set, = ..................................................................................................................................... 97
5.11 .org ..................................................................................................................................................... 98
5.12 .section ........................................................................................................................................... 98
5.13 .end ................................................................................................................................................... 102
5.14 Les opérations assembleur .................................................................................................................. 102
5.15 Les structures de contrôle en assembleur ............................................................................................ 103
5.15.1 L’assemblage conditionnel avec .if ......................................................................................... 103
5.15.2 L’assemblage conditionnel avec .ifdef .................................................................................. 104
5.15.3 L’assemblage conditionnel avec .ifndef ................................................................................. 104
5.16 La définition de macro avec .macro ................................................................................................. 104
5.17 Les structures de répétitions en assembleur ........................................................................................ 106
5.17.1 La répétition avec .rept ........................................................................................................... 106
5.17.2 La répétition paramétrée avec .irp ........................................................................................... 107
6 Les sous routines .......................................................................................................................................... 109
6.1 Introduction ......................................................................................................................................... 109
6.2 Appel et retour de sous routine ........................................................................................................... 109
6.2.1 Appel de sous routine .................................................................................................................. 109
6.2.2 Appel emboîté de sous routine et la pile (stack).......................................................................... 110
6.3 La sauvegarde du contenu des registres .............................................................................................. 114
6.4 Le transfert des paramètres ................................................................................................................. 114
6.4.1 Le transfert de paramètres à l’aide de registre............................................................................. 114
6.4.2 Le transfert de paramètres avec la pile ........................................................................................ 116
6.5 APCS................................................................................................................................................... 117
6.6 Définition de variable locales.............................................................................................................. 118
6.7 Sources d’erreurs................................................................................................................................. 119
6.8 Comparaison entre sous routine et macro ........................................................................................... 119
7 Les interruptions et les exceptions ............................................................................................................... 120
7.1 Introduction ......................................................................................................................................... 120
7.2 Les interruptions ................................................................................................................................. 121
7.3 Les exceptions/interruptions du STM32F407xx ................................................................................. 122
7.4 Les propriétés des exceptions/interruptions ........................................................................................ 122
7.5 L’activation et le masquage des interruptions ..................................................................................... 123
7.6 La priorité des exceptions/interruptions .............................................................................................. 124
7.7 Le tableau des vecteurs d’interruption ................................................................................................ 126
7.8 Déroulement d’une requête d’interruption .......................................................................................... 127
7.9 Le comportement temporel des interruptions ...................................................................................... 130
7.10 Les variantes pour le traitement d’interruptions.................................................................................. 131
8 Les Structures de contrôle en assembleur .................................................................................................... 133
8.1 Introduction ......................................................................................................................................... 133
Version 3.1, juin 2008 Page IV

8.2 La ramification simple ........................................................................................................................ 134

8.3 La ramification multiple ...................................................................................................................... 135
8.4 La boucle avec évaluation de la condition au début ............................................................................ 137
8.5 La boucle avec évaluation de la condition à la fin .............................................................................. 138
8.6 La boucle itérative ............................................................................................................................... 138
9 Les structures de données en assembleur ..................................................................................................... 140
9.1 Introduction ......................................................................................................................................... 140
9.2 Les Tableaux unidimensionnels .......................................................................................................... 140
9.3 Les Tableaux multidimensionnels ....................................................................................................... 141
9.4 Les chaîne de caractères ...................................................................................................................... 142
9.5 Les structures ...................................................................................................................................... 142
9.6 La pile (stack)...................................................................................................................................... 143
9.7 Queues et anneaux de tampons (Queue / Ring buffers) ...................................................................... 145
10 Le démarrage d’un programme C ............................................................................................................ 147
10.1 Le processus de démarrage d’un programme C .................................................................................. 147
10.2 Le reset ................................................................................................................................................ 147
10.3 Le code de démarrage du système (boot loader) ................................................................................. 147
10.4 Le code de démarrage de l’application................................................................................................ 148
10.5 Le programme principale .................................................................................................................... 151
11 L’interface C et assembleur ..................................................................................................................... 153
11.1 Introduction ......................................................................................................................................... 153
11.2 Les appels des sous routines assembleur depuis le C .......................................................................... 153
11.3 Transmission de paramètres aux sous-routines assembleur ................................................................ 154
11.4 Les registres utilisés par le compilateur .............................................................................................. 154
11.5 L’utilisation de variables en commun ................................................................................................. 154
11.6 L’assembleur en ligne ......................................................................................................................... 155
12 L’adressage des registres en C ................................................................................................................. 157
12.1 L’adressage avec #define ............................................................................................................... 157
12.2 La définition de sections absolues ....................................................................................................... 157
12.3 L’utilisation de mots clés spécifiques du fabriquant ........................................................................... 158
Annexe A : Le stockage des nombres .................................................................................................................. 159
Annexe B : Les formats des nombres................................................................................................................... 160
Complément à deux ........................................................................................................................................ 160
Nombre à virgule flottante .............................................................................................................................. 160
Annexe C : Les vecteurs d’interruption ............................................................................................................... 161
Annexe D : La documentation ............................................................................................................................. 165
Annexe E : Le jeu d’instructions Thumb ............................................................................................................. 166
Annexe D : Tableau des valeurs ASCII ............................................................................................................... 167
Index .................................................................................................................................................................... 168
Version 3.1, juin 2008 Page V

Informatique 3 Architecture d’un microordinateur standard
1 Architecture d’un microordinateur standard

Ce chapitre traite l’architecture des microprocesseurs et le principe de fonctionnement du matériel (hardware),
qui comprend la CPU (Central Processing Unit), la MMU (Memory Management Unit), le DMA (Direct
Memory Access), la mémoire externe et les composants périphériques. Ce chapitre traite le sujet de manière très
générale, sans distinction entre les différentes familles de CPU.
1.1 Les catégories des ordinateurs

1.1.1 La classification selon Flynn
Selon Michael J. Flynn, les ordinateurs peuvent être répartis en quatre catégories. Cette classification se base sur
la structure des instructions du programme et des jeux de données. En effet, ces derniers peuvent être soit
« simples » ou « multiples ».
SISD SIMD
Single Instruction, Single Data Single Instruction, Multiple Data
Ordinateur séquentiel Ordinateur vectoriel en pipeline
MISD MIMD
Multiple Instruction, Single Data Multiple Instruction, Multiple Data
Tableau systolique Multiprocesseur et multi ordinateurs
Tableau 1 : Les catégories des ordinateurs
SISD:
Les ordinateurs SISD travaillent de façon séquentielle. Ces
derniers traitent un seul jeu de donnée en fonction d’une seule load A
instruction : load B
t
Single instruction veut dire, qu’une instruction est exécutée par C=A+B
cycle d’horloge. store C
Single Data veut dire, qu’un jeu de donnée est traité par cycle
d’horloge. CPU
Les ordinateurs SISD sont les ordinateurs les plus répandus,
comme par exemple les ordinateurs personnels (PC) ou les
stations de travail.
Toutefois, avec l’introduction des processeurs multi corps, les
systèmes MIMD seront bientôt plus nombreux.
SIMD:
Les ordinateurs SIMD permettent d’exécuter la même instruction
sur plusieurs jeux de données. Ces derniers sont utilisés par load A1 load A2
exemple pour le traitement des images (JPEG, MPEG). load B1 load B2
t
Single Instruction veut dire, que tous les CPU exécutent la même C1 = A1 + B1 C2 = A2 + B2
instruction à un cycle d’horloge donné. store C1 store C2
Multiple Data veut dire, que chaque CPU traite un jeu de donnée
différent. CPU 1 CPU 2
De nombreux microprocesseur, comme par exemple les PowerPC
ou les x86, possèdent des extensions SIMD avec des instructions
supplémentaires. La CPU peut ainsi traiter simultanément
plusieurs jeux de données, en fonction d’une seule instruction.
Version 3.1, juin 2008 Page 1

MISD:
Un seul jeu de donnée est traité simultanément par plusieurs
CPU, avec des instructions différentes. load A1 load A1
Multiple Instruction veut dire, que chaque CPU exécute une load B1 load B1
t
instruction différentes. C1 = A1 + B1 C2 = A1 * B1
Single Data veut dire, que chaque CPU traite le même jeu de store C1 store C2
donnée.
Les ordinateurs MISD ne sont presque plus utilisés aujourd’hui. CPU 1 CPU 2
MIMD:
Aujourd’hui presque tous les ordinateurs multiprocesseurs se
basent sur l’architecture MIMD. load A1 load D
Multiple Instruction veut dire, que chaque CPU exécute une load B1 E = func1(D)
t
instruction différente par cycle d’horloge. Des programmes C1 = A1 + B1 F=D/2
entiers ou des partitions de ces derniers (process, Thread, task) store C1 func2()
sont souvent répartis entre les différents CPU.
Multiple Data veut dire, que chaque CPU traite un jeu de données CPU 1 CPU 2
différent.
1.1.2 La communication chez les ordinateurs MIMD

Dans les systèmes MIMD, la communication entre les différents CPU s’effectue selon plusieurs principes :
a) Les systèmes fortement couplés (shared memory)

Plusieurs CPU partagent la même zone de mémoire
(shared memory). Mémoire
Tous les CPU travaillent indépendamment. Mais ils Bus
sont avertis, lorsqu’un CPU accède à une autre zone
de mémoire.
L’accès à la mémoire doit être synchronisé. Car CPU 1 CPU 2 CPU 3
plusieurs CPU ne peuvent pas accéder simultanément
à la mémoire.
Figure 1 : Les systèmes fortement couplés
b) Les systèmes faiblement couplés (distributed memory)

Plusieurs CPU communiquent à l’aide d’un réseau.
Réseau
Les CPU travaillent indépendamment et chaque CPU
possède sa propre zone de mémoire. Les échanges de
données entre les CPU ont lieu à l’aide du réseau. CPU 1 CPU 2 CPU 3
Ces systèmes peuvent être composés de plusieurs
systèmes SISD, reliés par un réseau.
Mémoire 1 Mémoire 2 Mémoire 3
Figure 2 : Les systèmes faiblement couplés
Comparaison entre les systèmes fortement et faiblement couplés :

Les systèmes faiblement couplés sont plus facilement extensibles. L’accès mémoire y est beaucoup plus rapide.
Par contre l’échange des données à travers le réseau est plus lent et plus complexe.
c) Combinaison de systèmes fortement et faiblement couplés :

Aujourd’hui, les ordinateurs les plus rapides sont souvent un mélange de systèmes fortement et faiblement

couplés. Cela découle des avantages et des désavantages de ces systèmes.
Mémoire CPU CPU Mémoire CPU CPU

CPU CPU CPU CPU
Réseaux
Mémoire CPU CPU Mémoire CPU CPU

CPU CPU CPU CPU
Figure 3 : Combinaison de systèmes fortement et faiblement couplés
1.2 Les architectures des microordinateurs

Il existe deux variantes pour le transfert des données entre la CPU et la mémoire : l’architecture de « Von
Neumann » et celle de « Harvard ». Les deux architectures appartiennent à la catégorie des systèmes SISD.
1.2.1 L’architecture de Von Neumann

Actuellement, l’architecture de la plus grande partie des ordinateurs est basée sur celle de Von Neumann,
nommé selon le mathématicien hongrois János Von Neumann (1903 – 1957). Dans cette architecture les
instructions du programme, ses structures de données et les composants périphériques partagent la même zone de
mémoire. La CPU accède ainsi aux instructions, aux données et à la périphérie avec un seul system de bus. Par
conséquent, les instructions et les données ne peuvent être chargées que séquentiellement. C'est-à-dire qu’il faut
au moins deux cycles d’horloge pour lire une instruction et les données à traiter.
Bus pour les instructions et les données
Mémoire
programme
Mémoire des
CPU données
Périphérie
Figure 4 : Architecture de Von Neumann
La mémoire programme, comme son nom l’indique, contient les instructions du programme. Cette dernière est
en générale non volatile, c’est à dire que son contenu n’est pas perdu lorsque l’alimentation est coupée. Quant à
la mémoire des données, elle contient les variables du programme et est en générale volatile. La CPU lit les
instructions dans la mémoire programme et traite (lecture et écriture) les variables, qui sont stockées dans la
mémoire des données ou les composants périphériques, en fonction de ces dernières.
Le goulot de Von Neumann désigne la limitation du transfert des informations entre la CPU et la mémoire
(programme et données). Ce goulot résulte du système de bus unique.

1.2.2 L’Architecture de Harvard

Dans l’architecture de Harvard les instructions et les données sont déposées dans deux zones mémoire distinctes.
Dans cette structure deux systèmes de bus (bus des instructions et bus de données) permettent l’accès aux
différentes zones mémoire. Les instructions et les données peuvent ainsi être lues simultanément (c’est à dire en
parallèle). La largeur des buses (instructions et données) peut être différente.
Mémoire des
données
Bus de données
Mémoire du
programme Bus des instructions CPU
Périphérie
Figure 5 : L’architecture de Harvard
L’architecture de Harvard est souvent utilisée dans les DSP (Digitale Signal Processor). L’avantage de cette
architecture réside dans la lecture simultanée des instructions et des données du programme. Cette architecture
est donc plus rapide que celle de Von Neumann, mais elle est également plus complexe, ce qui influence
forcément le prix.
Dans les chapitres suivant nous nous limiterons à l’architecture de Von Neumann.
1.3 La CPU
La CPU (Central Processing Unit) est le cœur de l’ordinateur. Il contrôle l’exécution du programme et traite les
données. La Figure 6 illustre la structure générale de la CPU. Cette dernière varie en fonction du type et du
fabriquant de l’ordinateur.
Bus de contrôle Bus d’adresse Bus des données
Interface du bus
Register
Program-Counter
Opérande
Bus interne
Instruction
Unit
ALU
Résultat
Unité de contrôle Unité de calcul
Figure 6 : Structure de la CPU

L’unité de contrôle est responsable de l’exécution du programme. Il est composé des éléments suivants :
 Instruction Unit (dispositif de commande) : Il interprète et exécute les instructions du programme.
 Program-Counter (PC): Il contient l’adresse de la prochaine instruction du programme à exécuter.
Les tâches de l’unité de contrôle sont les suivantes :

 Chargement des instructions du programme à partir de la mémoire programme (fetch), qui sont
adressées par le compteur de programme.
 Décodage des instructions programme (decode).
 Exécution des instructions programme (execute) en quatre étapes :
 Génération des signaux de contrôle pour l’ALU ou les autres unités de calcul.
 Adressage et chargement des opérandes.
 Stockage du résultat.
 Adaptation du compteur de programme.
L’unité de calcul est responsable du traitement des données. Il contient les composants suivants :
 ALU (Arithmetic Logical Unit), qui exécute les opérations arithmétiques et logiques. L’ALU n’exécute
que des opérations avec des nombres entiers. Pour des instructions à virgule flottante ou des instructions
mathématiques plus complexes on emplois souvent un FPU (Floating Point Unit). Les opérations
typiques sont les suivantes :
 Les opérations de transfert (chargement et stockage)
 Les opérations logiques (AND, OR, EXOR et NON)
 Les opérations arithmétiques (addition, soustraction, multiplication)
 Comparaison et décision (compare et réalise le saut de programme si la condition est réalisée)
 Les opérations de décalage (shift left, shift right)
 Les registres de données, qui sont destinés aux stockages des opérandes et du résultat des opérations
(accumulateur). Un registre est une case mémoire rapide, qui se trouve à l’intérieure du processeur. Ce
dernier peut être accédé directement, c’est à dire sans système de bus, par la CPU.
Le bus interne relie l’unité de contrôle, celle de calcul et l’interface du bus. L’unité de contrôle gère les
opérations, qui doivent être exécutées dans l’unité de calcul. Cette dernière retourne des informations concernant
son état à l’unité de contrôle. L’interface du bus gère la communication avec des composants externes (mémoire
et périphérie).
1.4 Le système de bus

1.4.1 Les bus d’adresse, de données et de contrôle
Différents bus relient la CPU aux composants externes. Ces bus permettent d’échanger des informations
concernant l’adresse et les données. Remarque : ce chapitre se limite à l’architecture de « Von Neumann ».

Bus de contrôle
Bus d’adresse
CPU
Mémoire Mémoire des Périphérie
programme données
Bus de données
Figure 7: Bus d’adresse, de données et de contrôle
Le bus d’adresse permet de transmettre les adresses (pour la sélection des cases mémoires) Avec qui?
aux composants externes (mémoire et périphérie), qui sont connectés à la CPU. Ces adresses
sont déterminées par l’unité de contrôle de la CPU. Souvent des décodeurs d’adresse
supplémentaire doivent être utilisés, afin de pouvoir sélectionner un des composants externes
(voir chapitre 1.4.3).
Le bus de données permet de transmettre les instructions et les données du programme. Ces quoi?
dernières sont
a) lues par la CPU à partir des composants de stockage externes (RAM ou ROM) ou
périphériques.
b) générées par la CPU et écrites dans les composants de stockage externes ou
périphériques.
Le bus de contrôle permet de transmettre des informations supplémentaires pour la gestion de comment?
la communication (read/write, reset, interrupts, requests et acknowledge, handshake etc.).
Exemple :
Le fonctionnent du système de bus peut être illustré plus en détail, à l’aide d’un transfert de données depuis la
périphérie, en passant par la CPU, à la mémoire des données. Exemple : lecture de la température à l’aide d’une
sonde x (périphérie) et stockage de cette dernière dans la variable "temp", qui se situe dans le RAM. En C cella
serait définie de la manière suivante :
int temp = Temperatur_Sensor_x;
1) La CPU dépose l’adresse de l’instruction à lire sur le bus d’adresse. Cette adresse est stockée dans le
compteur de programme (Program counter).
2) La CPU fixe le sens du transfert « lecture », à l’aide du bus de contrôle.
3) La mémoire programme fournit l’instruction stockée dans la case mémoire, qui est sélectionnée par le
bus d’adresse, sur le bus de donnée.
4) La CPU lit cette instruction.
5) La CPU fournit l’adresse du composant périphérique, à partir de laquelle les données doivent être lues,
sur le bus d’adresse.
6) La CPU fixe le sens du transfert « lecture », à l’aide du bus de contrôle.
7) La périphérie fournit l’information, contenue dans la case mémoire sélectionnée, sur le bus de données.
8) La CPU lit les données.
9) La CPU sélectionne la case de destination « temp » dans la mémoire de donnée, à l’aide du bus

d’adresse.
10) La CPU fournit les données sur le bus de données.
11) La CPU fixe le sens du transfert « écriture », à l’aide du bus de contrôle.
12) La mémoire des données saisit les données sur le bus de données, et les stocke dans la case mémoire
sélectionnée par le bus d’adresse.
Bus AMP APE AMD

d’adresse
Bus de DMP DPE DMD

données
Bus de RD RD WR
contrôle
1) 2) 3) 4) 5) 6) 7) 8) 9) 10) 11) 12)
Figure 8 : Le timing du bus
Les abréviations suivantes ont été utilisées dans la Figure précédente :

AMP : Adresse de la mémoire programme
APE : Adresse de la périphérie
AMD : Adresse de la mémoire des données
DMP : Donnée de la mémoire programme
DPE : Donnée de la périphérie
DMD : Donnée de la mémoire des données
RD : Read, lire
WR : Write, écrire
De plus les notations suivantes illustrent l’état de la tension du bus :
La tension du bus est stable et valable, elle est soit high ou low
La tension du bus n’est pas valable ("don't care")
La tension du bus change
1.4.2 Le plan de mémoire

Le plan de mémoire (memory map) définit les zones de mémoires pour les composants externes : comme par
exemple les mémoires externes (programme et données) ainsi que les composants périphériques. La Figure
suivante montre un plan de mémoire pour une zone d’adressage de 64 kilos bytes :

Adresse A15 A14 A13 A12

Périphérie 0xFFFF 1 1 1 1
0xE000 1 1 1 0
Non utilisé
Non utilisé
RAM 2 0xBFFF 1 0 1 1
(8kByte) 0xA000 1 0 1 0
RAM 1 0x9FFF 1 0 0 1
(8kByte) 0x8000 1 0 0 0
Flash 0x7FFF 0 1 1 1
(32kByte) 0 0 0 0 0
Figure 9 : Exemple d’un plan de mémoire avec un bus d’adresse de 16 bits
Les contrôleurs 8 bits (8 bit définit ici la largeur du bus des données) possèdent généralement un bus d’adresse
de largeur 16 bits. Ils sont ainsi en mesure d’adresser une zone de mémoire de 64 kilos bytes (0xFFFF). Quant
aux microcontrôleurs 32 bits, ils possèdent un bus d’adresse de largeur 32 bits et sont ainsi en mesure d’adresser
une zone de mémoire de 232 bytes (4 Giga bytes).
La taille de la mémoire dépend du type du contrôleur. Les contrôleur 8 bits possède en général quelques kilo
bytes de mémoire. Cela est suffisant, car ces derniers sont destinés aux applications relativement simples, qui ne
nécessitent pas de systèmes d’exploitation. Les contrôleurs 32 bits, qui sont destinés aux systèmes embarqués,
nécessitent en générale plusieurs Méga bytes de mémoire.
1.4.3 Le décodeur d’adresse

La tâche du décodeur d’adresse est de sélectionner un des composants externes. Admettons par exemple qu’un
système à microcontrôleur soit composé de plusieurs composants de stockage (RAM et ROM). Dans ce système,
du bus d’adresse ne suffit pas pour sélectionner un des composants. Par conséquent, il faut utiliser des signaux
de sélection (Chip Select, CS) supplémentaires. Ces signaux sont fournis par le décodeur d’adresse en fonction
des bits de poids plus fort du bus d’adresse.
Les décodages d’adresse simples sont réalisés avec de la logique discrète (AND, OR ou 1 of X decoder). Les
composants nécessaires pour réaliser ce genre de décodeur ne sont pas très chers. Toutefois, la logique discrète
nécessite plus de place sur la platine et elle n’est pas flexible. Par conséquent, les erreurs de conception ou les
éventuelles adaptations du plan de mémoire nécessitent souvent une nouvelle platine.
A cause des problèmes de la logique discrète décrits ci-dessus, les décodeurs d’adresse sont souvent réalisés à
l’aide de la logique programmable (GAL, PAL, CPLD etc.). Le décodeur d’adresse correspondant au plan de
mémoire de la Figure 9 peut être réalisé de la manière suivante :
CS0 Flash
CS1 RAM 1
Adresse Logique
program. CS2 RAM 2
CS3 Périphérie
Figure 10: Décodeur d’adresse programmable
Les équations logiques permettent de programmer ces décodeurs d’adresse. Par exemple les signaux CS pour le
plan de mémoire de la Figure 9 seraient programmés de la manière suivante :

CS1 = /A15
CS2 = A15 * /A14 * /A13
CS3 = A15 * /A14 * A13
CS4 = A15 * A14 * A13
La Figure suivante montre un schéma bloque d’un circuit contenant un décodeur d’adresse ainsi que des
composants de stockages externes et périphériques. Ce circuit contient une Flash de 32 kilos bits, deux RAM de
8 kilos bits et un convertisseur A/D à 1 Byte:
Bus de données
CS4
CS3 32k * 8 8k * 8 8k * 8 Périphérie
Décodeur RAM 1 RAM 2 (convertisseur
CS2 Flash
d’adresse A/D de 1 byte)
CS1
A0 .. A15 A0 .. A14 A0 .. A12 A0 .. A12
Bus d’adresse
Figure 11: Schéma bloque du circuit avec le décodeur d’adresse, les composants de stockage (Flash et ROM) et
périphérique
Remarque :
Ce schéma bloque ne contient pas les bits de contrôle /RD et /WR.
Le convertisseur A/D est sélectionné avec le chip select CS4. Du fait qu’il ne possède qu’une seule adresse
physique, il sera reproduit dans toute la zone de mémoire réservée à la périphérie. C'est-à-dire que la CPU peut
l’adresser entre 0xE000 et 0xFFFF.
1.5 La mémoire
1.5.1 Les technologies
Fondamentalement il existe les mémoires non volatiles, qui sont utilisée uniquement en lecture, et les mémoires
volatiles, qui peuvent être utilisées en lecture ou en écriture.
Mémoires non volatiles

Ces mémoires conservent leur contenu, même si leur alimentation est coupée. Les différents types de mémoire
non volatile sont les suivants :
 ROM (Read Only Memory) : Programmation par le fabriquant à l’aide de masques.
 EPROM (Erasable Programmable ROM) : Ces mémoires peuvent être programmées plusieurs fois par
l’utilisateur (outils de programmation spécifique) et effacés à l’aide de rayon UV.
 OTP (ou OTP ROM, One Time Programmable ROM) : Ces mémoires sont construites comme les
EPROM, toutefois sans fenêtre. Les OTP ne peuvent être programmées qu’une seule fois par
l’utilisateur.
 EEPROM (Electrical Erasable Programmable ROM) : Ces mémoires peuvent être effacées et
reprogrammées case par case durant leur fonctionnement. Les EEPROM ont une capacité réduite
(quelques kilos bytes) et sont, par conséquent, utilisées pour stocker les données de production,

comme par exemple les numéros de série etc.

 FLASH (la définition exacte est FLASH EEPROM) : Ces mémoires peuvent être effacés électriquement
par bloque durant leur fonctionnement (pas de possibilité d’effacer uniquement des cases, comme avec
les EEPROM). Les FLASH possèdent une grande capacité de stockage (quelques Mégas bytes) et sont,
par conséquent, souvent utilisées pour stocker le code du programme.
Mémoire volatile
Ces mémoires perdent leur contenu dès que leur alimentation est coupée. Ces mémoires sont en générale
qualifiées de RAM (Random Access Memory). Random veut dire que les cases mémoires peuvent être accédées
de façon aléatoire. Il existe les catégories suivantes :
 DRAM (Dynamic RAM) : Ces mémoires stockent l’information à l’aide de condensateur et doivent, par
conséquent, être rafraîchies périodiquement.
 SRAM (Static RAM) : Ces mémoires possèdent une structure plus complexe que les mémoires DRAM
mais, par contre, elles ne doivent pas être rafraîchies périodiquement. Les SRAM sont plus rapide,
nécessitent moins de courant et sont plus cher que les DRAM.
 SDRAM (Synchronous Dynamic RAM) : Ces mémoires sont une version cadencée des DRAM. La
fréquence d’horloge est prédéfinie par le bus du système. Chez les DDR-SDRAM (Double Data Rate
SDRAM), les accès mémoires sont possibles aux flans montant et aux flans descendants de l’horloge.
Aujourd’hui il est également possible de travailler avec des technologies RAM non volatile (FeRAM, MRAM).
Toutefois, ces dernières possèdent une faible capacité de stockage et sont relativement chères.
1.5.2 L’organisation de la mémoire

Les mémoires sont organisées comme un Tableau, qui contient des cases mémoires. La largeur de ces cases
dépend du type de la mémoire et correspond à 1, 8 ou 16 bits.
La Figure suivante montre la structure d’une mémoire organisée en byte :
Mémoire
Adresse Byte
La plus petite adresse 0 0
1 7 0 1
MSB LSB
~ ~
La plus grande adresse n n

Largeur de la mémoire
(ici byte)
Figure 12 : Structure d’une mémoire organisée en byte
Le nombre de bit d’adresses, qui sont utilisés pour adresser la mémoire, dépend de la taille de la mémoire. Avec
m bits d’adresse, il est possible d’adresser 2m cases mémoires. Par exemple avec 16 bits d’adresses, il est
possible d’adresser un do maire de 64 k (ce qui est souvent utilisé avec de microcontrôleur à 8 bits).
1.5.3 Les architectures

Les mémoires sont organisées de telle façon, que les informations sont stockées dans un Tableau des cases
mémoires (Memory-Matrix). L’adressage des cases mémoires s’effectue à l’aide de décodeur d’adresse. Les
signaux de contrôle comme CS, OE, R/W contrôle les driver du bus.
Architecture d’une ROM :

Row-Decoder
A0 .. Memory-Matrix
An
Column-Output
D0 ..
Dn Column-Decoder
An+1
.. Az
OE Control
CS
Figure 13 : L’architecture d’un composant ROM
Les composants ROM possèdent typiquement un bus de données de largeur 8 ou 16 bits. La largeur du bus
d’adresse dépend de la capacité de stockage. Les signaux de contrôle sont composés d’un CS (Chip Select) pour
la sélection du composant, d’un OE (Output Enable) pour activer des amplificateurs de sortie du bus de données.
La Figure 13 ne contient que les signaux de contrôle, qui permettent la lecture de la ROM. La programmation
nécessite des signaux de contrôle supplémentaires.
L’architecture d’une SRAM :

Row-Decoder
A0 .. Memory-Matrix
An
Column-In/Output
D0 ..
Dn Column-Decoder
An+1
.. Az
OE Control
CS
R/W
Figure 14 : L’architecture d’un composant SRAM
La structure des composants SRAM est identique à celle des composants ROM. Toutefois, le bus de données est
bidirectionnel, afin que la CPU puisse lire et écrire. Un signal de contrôle supplémentaire (Read/Write) est par
conséquent nécessaire, afin de pouvoir définir le sens de la communication. Certain fabriquant utilise même deux
signaux de contrôle distincts (Read et Write) pour réaliser cette tâche.
L’architecture d’un composant SDRAM

Chez les composants DRAM et SDRAM l’adresse n’est pas fournie entièrement sur le bus d’adresse. En effet,
afin de pouvoir réduire de nombre de pin, cette dernière est fournie en deux étapes : d’abord les adresses
colonnes et ensuite les adresses lignes. Deux signaux de contrôle supplémentaires sont donc nécessaires, afin de

pouvoir signaliser laquelle de ces adresses est fournie sur le bus d’adresse. Ces signaux sont le RAS (Row
Address Strobe) et le (Column Address Strobe) CAS.
Figure 15 : Diagramme de bloc du SDRAM K4S561633F de Samsung (4M * 16 Bit * 4 Banks),

source : [Samsung_SDRAM]
Le comportement temporel de la lecture d’une SRAM est le suivant :
ADDR row address column address
read row address

/RAS
disable output driver

/CAS
read column address
enable output driver
Dout valid
t access RAM
Figure 16: Le comportement temporel de la lecture d’une SDRAM
1.5.4 La documentation
Les caractéristiques les plus importantes des composants de stockage sont décrites dans la documentation, qui est
fournie par le fabriquant. Ces dernières sont typiquement:
 La taille de la mémoire (kilo bit ou kilo byte)
 Assignation des pins
 Organisation de la mémoire (bit, byte ou mot)
 Les caractéristiques DC (tension, consommation de courant ...)
 Les caractéristiques AC (temps d’accès ...)
 Table de vérité (logique de contrôle)

1.6 La hiérarchie de la mémoire

Chaque technologie de stockage possède ses avantages et ses désavantages. Par conséquent les composants de
stockage sont organisés de façon hiérarchique :
CPU Prix par bit Temps d’accès Capacité
Register Élevé Faible Faible
Cache
Mémoire de travail
Mémoire de masse Faible Élevé Élevé
Figure 17 : Hiérarchie des composants de stockage
Les registres :
Les registres sont des cases mémoire très rapide, destinées au stockage des opérandes et du résultat de l’ALU. La
CPU peut accéder directement aux registres, c’est à dire sans passer par le système de bus (voir également
chapitre 1.3).
La mémoire cache :
La mémoire cache est une mémoire intermédiaire, qui se situe entre les registres et la mémoire de travail. Cette
mémoire rapide est destinée au stockage des instructions (Instruction-Cache) et des données (Data-Cache) du
programme, qui doivent être utilisées souvent.
Les CPU actuelles sont en mesure de travailler à des fréquences d’horloge supérieures à celles de leurs systèmes
de bus. En d’autres termes, le temps d’accès à la mémoire de travail est supérieur aux cycles d’horloge interne du
processeur, et représente souvent le talent d’Achille des systèmes à microprocesseur. Par conséquent, lorsque la
CPU lit les instructions ou les données à partir de la mémoire de travail, elle les dépose également dans la
mémoire cache. Si ces données doivent être réutilisées, elles seront chargées automatiquement à partie de la
mémoire cache au lieu de la mémoire de travail. Ce procédé est transparent plus l’utilisateur, c'est-à-dire que le
contrôle la mémoire cache est effectué par le hardware.
On parle d’un « Cache Miss », lorsque des données ne sont pas disponibles dans la mémoire cache. Ces données
seront alors lues à partir de la mémoire de travail et stockées dans un « Cache Line », dont la taille est
typiquement de quelques bytes. Lorsque la mémoire cache est pleine, les « lignes de cache » existantes doivent
être sur écrites.
On parle d’un « Cache Hit », lorsque des données à charger sont disponibles dans la mémoire cache. L’accès à
ces données est plus rapide que si elles devaient être lues à partir de la mémoire de travail.
Les mémoires cache possèdent typiquement une taille de 100 kilos bytes. Toutefois, seul les microprocesseurs
puissants possèdent une telle mémoire.
Les mémoires caches peuvent être échelonnées. Le premier échelon est alors une mémoire cache interne, plus
petite mais très rapide (L1). Le second échelon est une mémoire RAM externe, plus grande mais moins rapide
(L2).
La mémoire de travail :
La mémoire de travail est destinée au stockage des instructions (Flash) et des données (SRAM et SDRAM) du

programme (voir également chapitre 1.5).

Dans le monde des ordinateurs personnels (PC), le code est copié depuis la mémoire de masse dans la RAM, et il
est exécuté à partir de cette dernière.
Dans le monde des systèmes embarqués, le code est exécuté soit à partir de la Flash ou il est copié depuis la
Flash dans la RAM, durant le processus de démarrage (boot), et est exécuté ensuite à partir de cette dernière.
La mémoire de masse :
Les mémoires de masse, comme par exemple les disques dures ou les CD, ne sont pas utilisées dans les systèmes
embarqués. Par contre, ces dernières sont souvent employées dans les PC industriels. Toutefois, il ne faut pas
oublier les désavantages de la mécanique dans les environnements industriels (la température, les vibrations,
l’humidité, la poussière etc.). Par conséquent, on préfère utiliser ici les cartes CF, les cartes SD ou les mémoires
sticks en tant que mémoire de masse.
1.7 La MMU
Die MMU (Memory-Management Unit) est une unité hardware destinée à la gestion de la mémoire. Les
avantages du MMU apparaissent essentiellement avec les systèmes d’exploitation. Avec les processeurs 32 bits,
la MMU est souvent intégrée sur le même chip que celui de la CPU.
La MMU met à disposition les fonctionnalités suivantes :

1. Protection des segments de mémoire des différents programmes : Un système d’exploitation peut ainsi
exécuter plusieurs programmes simultanément. La MMU empêche qu’un programme puisse accéder au
segment de mémoire d’un autre programme. Cette fonctionnalité est très importante pour les systèmes
embarqués, car elle permet d’augmenter leur sécurité.
2. La mémoire de masse peut contenir plus de code que la mémoire de travail. Le code à exécuter est
toujours copié depuis la mémoire masse dans la mémoire de travail. Le code, qui n’est pas utilisé, sera
ainsi sur écrit. Par conséquent, les données, qui ne sont pas utilisées temporairement, doivent être
sauvées sur la mémoire de masse (swapping). Ces fonctionnalités sont importantes dans le domaine de
la bureautique, ou de nombreux programmes sont à disposition sur la mémoire de mass. Par contre,
elles ne sont pas importantes dans les systèmes embarqués.
1.7.1 Les adresses physiques et virtuelles

Les adresses virtuelles ou logiques désignent les adresses, qui sont attribuées au programme par le compilateur /
relieur et qui sont utilisées durant l’exécution du programme dans la CPU. Ainsi il est possible d’exécuter
plusieurs programmes en parallèle, qui possèdent tous une adresse virtuelle de base 0.
Les adresses physiques désignent les adresses, qui sont fournies sur le bus d’adresses durant l’exécution du
programme (adresses physiques des composants).
 Le programme et la CPU travaillent avec des adresses virtuelles. Les accès aux composants de
mémoire s’effectuent avec des adresses physiques.
Processeur
CPU
CPU fournit une
adresse virtuelle Mémoire Mémoire de Peripherie
de travail masse
MMU
MMU fournit une
adresse physique pour
accéder à la mémoire
Bus

Figure 18: La MMU entre la CPU et la mémoire
La tâche du MMU est de transformer l’adresse virtuelle en une adresse physique ou de réallocation (relocation).
Pour obtenir l’adresse physique, la MMU additionne l’adresse virtuelle à la valeur qui est contenue dans les
registres de réallocation (relocation register). Simultanément il contrôle si l’accès au segment est autorisé ou non,
à l’aide des registres de limitation.
Le fonctionnement du MMU peut être schématisé de la manière suivant :
Limit Relocation
register register
jes Work
CPU < + memory
Programm
Virtual Physical
address no address
Address error MMU

Trap
Figure 19 : Schéma bloc simplifié du MMU
Lorsque l’on passe d’un programme à un autre, il faut recharger les registres de réallocation et de limite. Ce qui
est la tâche du système d’exploitation. Chez les processeurs, qui ne possèdent pas de MMU, Les adresses
virtuelles correspondent aux adresses physiques.
1.7.2 Pages et trames, Tableau de pages

La zone de mémoire virtuelle est partagée en blocs de tailles identiques, qui sont appelé « pages ». La zone de
mémoire physique est également partagée en blocs de tailles identiques, qui sont appelé « trames ». La taille des
pages et des trames dépend des systèmes et se situe entre 512 bytes à 16 Méga bytes.
Des Tableaux de pages sont utilisés pour convertir les adresses virtuelles en adresses physiques. Les adresses
virtuelles sont composées des champs suivants :
1. Le numéro de la page, qui indique l’index du Tableau de pages. Le Tableau de pages contient l’adresse
de base de chaque trame (adresse physique).
2. Un offset de page, qui est additionné au contenu du Tableau de pages (adresse de base) pour construire
l’adresse physique.

Adresse physique
0 1 0 0 0 0 0 0 0 0 0 10 0 0 0
Numéro de trame = 2
obtenu du tableau de
page
15 000 0
14 000 0
13 000 1
12 000 0
11 111 1
Tableau 10 000 0
de page 9 101 1
8 000 0
7 100 1
6 000 0
5 011 1
4 010 1 010
Numéro de page = 4 3 110 1
correspond à 2 000 0
l’indexe du tableau
de page 1 001 1 Offset
bit de
0 000 0 validité
0 1 0 0 0 0 0 0 0 0 0 0 10 0 0 0
Adresse virtuelle
Figure 20 : MMU avec 16 pages de 4 k bytes
La Figure de l’exemple de ci-dessus montre, que les zones de mémoire virtuelles peuvent être plus grandes que
les zones de mémoire physiques. Le bit de validité indique si le contenu du Tableau de pages est valide ou pas.
Si ce n’est pas le cas, les données doivent d’abord être copiées depuis la mémoire de masse dans la mémoire de
travail.
1.7.3 Les tampons auxiliaires de traduction

Les Tableaux de pages peuvent devenir très grands, en fonction de la taille des pages et du volume de mémoire
qu’ils représentent. D’un autre côté, les programmes utilisent relativement peu ces Tableaux (boucle, Tableaux
etc.).
Le calcul des adresses physique peut être optimisé à l’aide des tampons auxiliaires de traduction (Translation
Look aside Buffers abrégé en TLB). Ces derniers sont également intégrés dans la MMU. Le TLB est un Tableau
contenant 8 à 64 entrées, qui correspondent aux entrées des Tableaux de pages.

Numéro de la Trames Validité modification protection

Page (virtuel) (physique)
36 22 1 0 rwx
18 54 1 1 r x
632 60 1 0 rw
320 52 1 0 rw
Tableau 2 : Exemple de demande pour le TLB
Le TLB contient des informations sur les pages : numéro de la page, trame, bit de validité, bit de modification
(montre si le contenu d’une trame a été modifié et, par conséquent, si ce contenu doit être sauvé avant son
élimination) et bits de protection (droit d’accès sur une trame donnée).
Le processus de la conversion de l’adresse virtuelle en une adresse physique est le suivant : D’abord la MMU
contrôle si la page recherché existe dans le TLB. Pour cela la demande est comparée avec les numéros de page
du TLB. Lorsqu’il y a correspondance (TLB hit), le numéro de la trame est lu directement à partir du TLB.
Lorsqu’il n’y a pas de correspondance (TLB miss), la MMU continue la recherche avec le Tableau de pages.
Finalement une demande est choisie dans le TLB et est remplacée avec le numéro de la page, contenu dans le
Tableau de pages. Le TLB contient par conséquent tous les numéros de pages, qui ont été utilisés récemment.
Adresse virtuelle
CPU Numéro Offset
Page Frame
Number Number
TLB hit
TLB
Numéro Offset Mémoire

Page Frame
Number Number Adresse physique
TLB miss
Page Table
Figure 21 : MMU avec un Tableau de pages et un TLB
1.8 DMA
L’accès direct à la mémoire (Direct Memory Access abrégé par DMA) est un procédé, qui permet de transférer
rapidement les données entre la mémoire de masse, ou les composants périphériques, et la mémoire de travail.
Un contrôleur DMA est nécessaire pour cela.
Sans le contrôleur DMA, les transferts des données entre la périphérie et la RAM doivent passer par la CPU.
Dans ce cas, ce dernier doit gérer les adresses source, les adresses de destination et les registres tampons. Ce
transfert doit bien entendu être programmé et nécessite, par exemple, plusieurs cycles de bus pour ne transférer

qu’un mot. Ce qui a tendance de fortement ralentir les transferts.
I/O I/O Mémoire
CPU
Figure 22 : Transfert de données à travers la CPU
Le contrôleur DMA permet de transférer les données sans que ces derniers passent par la CPU. La CPU est alors
découplé du bus, afin que contrôleur DMA puisse reprendre le contrôle de ce dernier. La tâche de la CPU se
limite dans ce cas à l’initialisation du contrôleur DMA (adresse source, adresse destination et quantité de
données).
I/O I/O Mémoire
CPU Contrôleur
DMA
Figure 23 : Transfert de donnée avec le DMA
1.9 La périphérie
Les composants suivant sont considérés comme périphériques :
a) Les composants qui permettent d’accéder aux données de l’environnement du système. Ces données
sont lues avec des senseurs ou d’autre type d’interfaces.
b) Les composants qui permettent de transmettre les données à l’environnement du système. Ces données
sont transmises avec des actuateurs ou d’autres types d’interface.
La périphérie représente l’interface entre le processeur et son environnement. Les composants périphériques sont
en général connectés au bus du processeur.
1.9.1 Les amplificateurs de sortie

Les signaux de sortie d’un chip, qui sont fournis à l’aide des pins, doivent être amplifiés. Il existe différents
types d’amplificateur de sortie, dont le choix dépend de l’application.

D
Port Port Port
Out Out Out
Totem-Pole Open Drain Tri state

Figure 24 : Amplificateur de sortie
Les étages totem pole

Les étages totem pole fournissent toujours un signal à leur sortie. Par conséquent, ils ne peuvent pas être
connectés en parallèle !
a) La logique low est représentée le plus souvent par « 0 »
b) La logique high est représentée le plus souvent par « 1 »
Open Drain
Les sorties Open Drain (avec la technologie FET) ou Open Collector (avec la technologie bipolaire) possèdent
un seul transistor, qui permet de tirer une résistance (Pull-up) contre la masse. Les résistances pull-up peuvent
être sois internes ou externes. Les sorties Open Drain et Open Collector peuvent être connectées en parallèle,
comme par exemple avec les sources d’interruption :
Source Source Source

Pull d’interrup. d’interrup. d’nterrup.
up 1 2 3
IRQx
Figure 25 : Source d’interruption avec des sorties Open Drain
Tri state
Les sorties tri state peuvent avoir un état à haute impédance. L’état de sortie active ou « tri state » est activée à
l’aide d’un signal de contrôle supplémentaire (G).
En générale les sorties, qui fournissent des signaux sur un bus, sont réalisées avec des tri states, comme par
exemple les entrées et sorties des données (I/O) d’une RAM.
1.9.2 Digital Input / Output

Les entrées et sorties digitales sont utilisées respectivement pour la lecture et l’écriture des signaux digitales. Il
existe deux possibilités pour fournir des entrées sorties digitales :
1) Utilisation de pins du microcontrôleur, appelés GPIO. Le nombre de ces pins varie en fonction de la
famille des microcontrôleurs. L’accès à ces derniers s’effectue à l’aide de registres.
2) Utilisation de composants périphériques supplémentaires (FPGA, PIO, …), qui mettent à disposions des
I/O. La communication avec ces composants s’effectue avec le système de bus.
Les entrées et sorties digitales sont utilisées pour connecter les éléments d’affichage (lampes, LED etc.), les
relais, les moteurs, les soupapes etc.
Les sorties digitales possèdent souvent un étage d’amplification, afin qu’elles puissent fournir le courant
nécessaire à la transmission (ex. contrôle des moteurs, des soupapes etc.). Les entrées digitales possèdent
souvent des filtrés (circuit RC et trigger de Schmitt). Elles sont également protégées contre les sur tensions
(comme par exemple à l’aide de diodes Transzorb et des varistances).

Contrôleur de
Microcontrôleur moteur
Motor
GPIO1
GPIO2
Interrupteur
…
Protection
d’entrée
Figure 26 : Exemple d’utilisation de GPIO
1.9.3 L’interface sérielle

Les interfaces sérielles sont utilisées pour transmettre des données de façon sérielle (ex. RS232, I2C, SPI,
FireWire, USB etc.). Un registre à décalage est nécessaire pour convertir les données, depuis le format parallèle
en séquence de bits, afin de pouvoir réaliser la transmission.
Les propriétés les plus importants de la transmission sérielle sont les suivants :
 Le nombre de bit par seconde (baud rate)
 La tension
 Le protocole
TxD RxD Steuersignale
Sende-Schieberegister Empfangs-Schieberegister Control-Register
CPU
Figure 27: Principe de fonctionnement d’une interface sérielle
1.9.3.1 RS232
L’interface RS232 est très importante dans le domaine des systèmes embarqués. Cette interface permet par
exemple de gérer un affichage LCD ou une ligne de commande (Command Line Interface). La plupart des
microcontrôleurs possèdent déjà une interface RS232. Toutefois, les tensions de sortie de ces dernières
correspondent au niveau TTL. Par conséquent, un convertisseur de tension externe doit être ajouté au système.
Les interfaces RS232 sont accessibles à l’aide de registres.

 Les tampons de transmission et de réception, contiennent 1 byte. Les deux tampons possèdent souvent
la même adresse, car il n’est possible que d’écrire dans le tampon de transmission et de lire à partir du
tampon de réception.
 Les registres de contrôle, qui permettent de définir les modes de fonctionnement (la fréquence de
transmission (baud rate), le format des données, le bit de parité etc.) et les interruptions.

Les interfaces RS232 soutiennent différents modes de fonctionnement. Par exemple ils peuvent fonctionner soit
en mode synchrone ou en mode asynchrone. La fréquence de transmission est souvent définie avec un timer
standard. Certaine interface RS232 possèdent toutefois leur propre générateur de fréquence. Le timer peut ainsi
être utilisé pour d’autres applications.
Le schéma bloc de l’interface RS232 est typiquement le suivant :
Transmitter
Transmit FIFO
Transmit Holding Register
Transmit Shifter TxD

Internal Bus
Control Baudrate
Unit Generator
Receiver
Receive Shifter RxD
Receive Holding Register
Receive FIFO
Figure 28 : Schéma bloc de l’interface RS232 du microcontrôleur C515C

(Source: Manuel d’utilisation du C515C)
1.9.3.2 SPI
L’interface SPI (Serial Peripheral Interface) est un système de bus sériel à haut débit, destiné à la communication
entre le microcontrôleur et la périphérie. Ce dernier est souvent utilisé pour la communication avec des
extensions I/O, des affichages LCD ainsi que des convertisseurs A/D et D/A. Il peut également être utilisé pour
la communication entre microcontrôleurs.
La Figure 29 montre le principe de fonctionnement du SPI.

Entré des données Générateur de la Entré des données

en parallèle fréquence d’horloge en parallèle
7 0 7 0
Sortie des données Sortie des données

en parallèle en parallèle
Participant 1 Participant n
Figure 29 : Principe du SPI
L’interface SPI est toujours utilisée en mode maître esclave. Le maître est alors responsable de la génération de
la fréquence d’horloge. Le SPI peut travailler de façon duplexe à l’aide de deux lignes de transmission : MOSI
(Master Out Slave In) et MISO (Master In Slave Out). Les esclaves peuvent être connectés soit de façon
parallèle (c’est à dire que toutes les sorties des esclaves sont rassemblée et connectées à l’entré MISO du maître)
ou de façon sérielle (la sortie d’un esclave est connectée à l’entrée du prochain esclave et la sortie du dernier
esclave est connecté à l’entrée MISO du maître).
Le microcontrôleur écrit les données à transmettre dans un tampon de transmission. Ces dernières sont
sérialisées à l’aide d’un registre à décalage (comme une transmission RS232). Les données reçues sont
également converties à l’aide d’un registre à décalage. Le microcontrôleur peut alors lire ces données de façon
parallèle dans le tampon de réception. Du fait que les interfaces SPI ont une bande passante relativement élevé,
les tampons de transmission et de réception contiennent souvent plusieurs bytes.
Donnée Donnée
Registre à Registre à
décalage décalage
Esclave SPI 2 Esclave SPI 1
MOSI
MISO
SCK
Sélection Horloge Registre à

esclave décalage
FIFO de FIFO de
SPI maître réception tansmission
Figure 30 : SPI avec un maître de deux esclaves

1.9.3.3 I2C
Le bus I2C (Inter Integrated Circuit) a été développé par l’entreprise Philips. Ce bus est utilisé pour connecter les
composants périphériques comme l’EEPROM, les affichages LCD ou RTC (Real Time Clock) au
microcontrôleur.
Le bus I2C est composé de deux fils, ce qui réduit la partie hardware de façon drastique. Ce bus comprend une
ligne d’horloge SCL (Serial Clock) et une ligne de donnée SDA (Serial Data). La communication est par
conséquent synchrone. Les modes d’utilisation du bus sont maître et esclave.
La Figure suivante illustre une application typique avec le bus I2C :
Figure 31 : Application avec un bus I2C, source [Philips_I2C]
Le protocole est défini de la manière suivante:
Figure 32 : Le maître (transmetteur) adresse l’esclave (récepteur) avec une adresse composé de 7 bits
et envoi 2 bytes de données, source [Philips_I2C]
Le transfert de données entre le maître et l’esclave s’effectue de la manière suivante :

1. Le maître démarre le transfert des données en envoyant le bit de démarrage. Tous les esclaves entrent
ainsi dans un état passif d’écoute.
2. Le maître envoie ensuite l’adresse de l’esclave, avec lequel il aimerait communiquer. Cette adresse est
composée de 7 bits.
3. Le maître envoi le bit R/W, qui fixe le sens de la communication : Ecriture depuis le maître à l’esclave
ou lecture depuis l’esclave au maître
4. Le protocole I2C exige des confirmations (acknowledge) après chaque transmission d’un byte.
L’esclave accrédite avec le premier bit de confirmation, qu’il est prêt pour la communication.
5. Le transfert de données a lieu entre le maître et l’esclave. Un bit de confirmation est également échangé
ici après chaque transmission d’un byte. Ce bit est fourni par le maître dans le mode lecture et par
l’esclave dans le mode écriture.
6. Le transfert se termine avec un bit d’arrêt.
Le nombre de bytes à transmettre et le sens de la transmission peuvent varier selon les composants utilisés. Ces
informations sont fournies par documentation de ces derniers. Par exemple : le maître n’écrit qu’un byte dans
un convertisseur D/A. Alors qu’avec une EEPROM, qui possède une zone de mémoire interne, le maître doit

d’abord envoyer l’offset de la case mémoire à accéder. Le transfert de données n’est effectué qu’ensuite,
jusqu'au bit d’arrêt.
Le Tableau suivant illustre quelques exemples de transmission de données avec l’interface I2C (le bit
confirmation n’est pas affiché) :
Composant Protocole
Convertisseur Démarrage Adresse Wr Données Arrêt
D/A de
l’esclave
Ecriture RAM Démarrage Adresse Wr Données Données Arrêt
de
l’esclave
Lecture RAM Démarrage Adresse Wr Données Arrêt Démarrage Adresse Rd Données Arrêt
de de
l’esclave l’esclave
Figure 33 : Exemple pour le protocole I2C
Le protocole I2C est défini au niveau électrique de la manière suivante :

Niveau de pause :
Le niveau de pause est high.
Condition de démarrage :
La condition de démarrage est définie par un flanc descendant sur SDA, suivi d’un flanc descendant sur SCL. Ce
signal est univoque et n’apparaître pas durant une transmission normale.
Condition d’arrêt:
La condition d’arrêt est définie par un flanc montant sur SCL, suivi d’un flanc montant sur SDA. Ce signal est
également univoque et n’apparaît par durant une transmission normale.
SDA
SCL
Start Stop
Figure 34 : Condition de démarrage et d’arrêt
Les bits de données :

La valeur du signal SDA est fixée en fonction du bit à transmettre : 0 = low, 1 = high. La validité est signalée
avec un flanc montant du signal SCL. La lecture et l’écriture des bits de données ont toujours lieu pendant que le
signal SCL est haut.
ACK :
Le bit de confirmation (Acknowledge) veut dire que la réception est a été bonne ou que le récepteur est prêt pour
des transmissions supplémentaires. Du point de vue du maître, l’esclave doit confirmer chaque byte écrit. Du
point de vu de l’esclave, le maître doit confirmer chaque byte lu. Si ces confirmations n’ont pas lieu, le processus
de transmission sera rompu avec le bit d’arrêt.
NACK :
Not Acknowledged signal une erreur de transmission ou la fin de la disposition à recevoir.

SDA 1 0 0 1 0 1 1 1
SCL
Start Slave-Adressse R/W ACK Stop
Figure 35: Transmission au niveau bit
Dans la Figure 35, le maître envoi en premier la condition de démarrage, ensuite il envoi l’adresse de l’esclave
(1001011) et pour finir le bit R/W. L’esclave doit signaler sa présence avec le bit de confirmation. Il est
important que le maître maintienne le SDA à un état haut impédance durant cette phase. Les données peuvent
être transmises après le bit de confirmation (cela n’est pas montré dans la Figure). La communication est
interrompue avec le bit d’arrêt.
Admettons que l’on veut connecter un émetteur à plusieurs participants avec un bus I2C. Dans ce cas tous les
participants doivent se mettent dans un état à haute impédance. Certain microcontrôleur peuvent configurer leurs
sorties en tri state. Si cela n’est pas possible, il faut configurer les pins SCL et SDA en entrée.
1.9.4 Le timer
Le timer est utilisé comme base de temps dans les processeurs (système d’exploitation, horloge etc.) ou pour les
composants externes (ex. signal PWM, horloge pour les interfaces sérielles ...).
Oscillateur
Timer
Mode Timer / Counter Overflow
Register Flag
Counter
Entrée
externe
Figure 36 : Principe de fonctionnement du timer
En générale des registres de 8 ou 16 bits sont utilisés dans les timers ou les compteurs. Dans le mode timer, ces
registres sont incrémentés périodiquement à l’aide de l’horloge interne du système. Dans le mode compteur,
cette incrémentation s’effectue en fonction de signaux externes.
Lorsqu’il y dépassement de capacité (c'est-à-dire au passage de 0xFFFF à 0 avec un registre de 16 bits), le

drapeau (flag) d’overflow est mis à un. Ce dernier peut être observé à l’aide d’une boucle software (polling) ou il
peut générer une interruption.
Le mode « de rechargement automatique» (auto reload) permet d’initialiser le registre du timer avec une valeur
prédéfinie, qui est contenue dans le « registre de rechargement » (reload register). Ce qui permet de générer des
signaux avec des périodes variables.

Oszillator Timer Overflow

Register Flag
Reload
Reload
Register
Figure 37: Timer dans le mode de rechargement automatique
Dans le mode de rechargement automatique, il n’y a pas seulement une mise à un du flag overflow, mais le
compteur du timer est également initialisé avec la valeur du registre de rechargement.
1.9.5 Les convertisseurs A/D

Les convertisseurs A/D mesurent une tension analogique à leur entrée, comparent cette tension avec des tensions
de référence, et en fournissent l’équivalent digital à leur sortie. Le microcontrôleur peut lire cette valeur soit avec
un système de bus ou avec une interface sérielle (comme par exemple le SPI).
Les convertisseurs A/D possèdent souvent plusieurs entrées analogiques, qui peuvent être sélectionnées à l’aide
d’un multiplexeur.
Les caractéristiques les plus importants pour un convertisseur A/D sont les suivants :
 Largeur de bit (les valeurs typiques sont 8, 10, 12 ou 16 bits)
 Temps de conversion
Analog Inputs VREF
MUX S&H A/D

Converter
Control-Register Data-Register
CPU
Figure 38 : Principe d’un convertisseur A/D
1.9.6 Les convertisseurs D/A

Les convertisseurs D/A lisent une valeur digitale à leur entrée, convertissent cette valeur en une tension
analogique et fournissent cette dernière à leur sortie.

Les caractéristiques les plus importants pour un convertisseur D/A sont les suivants:
 Largeur de bit (les valeurs typiques sont 8, 10, 12 ou 16 bits)
 Temps de conversion
La conversion D/A peut être également effectuée avec une sortie PWM, qui est connectée à un filtre passe bas.
1.10 Les types de processeur

Un processeur est un chip qui contient au minimum un CPU. Il existe plusieurs sorte de processeurs : les
microprocesseur, les microcontrôleur et les DSP. Dans les chapitres suivants l’expression processeur représente
tous les types de processeur.
1.10.1 Les microprocesseurs

Un microprocesseur contient uniquement une unité de contrôle et une unité de calcul. Tous les composants de
stockage et périphériques sont externes. Par conséquent, ils ne sont accessibles qu’avec le système de bus.
1.10.2 Les microcontrôleurs

Les microcontrôleurs sont conçus essentiellement pour les applications de contrôle et sont, par conséquent,
optimisés au niveau du coût. En plus de la CPU, ils contiennent également de la mémoire interne, pour le
stockage des instructions et des données du programme, ainsi que des modules périphériques (en fonction de la
famille des microcontrôleurs).
1.10.3 Les DSP

Les DSP sont conçus pour les applications de traitement du signal digital, qui nécessitent des puissances de
calcul élevées. Ils sont utilisés pour l’exécution d’algorithmes complexes (ex filtrage, transformation de Fourier
etc.). Un DSP contient toujours un module pour la multiplication. Une opération de multiplication et d’addition
peut ainsi être effectuée simultanément, en un seul cycle d’horloge. L’architecture des DSP est normalement
celle de Harvard.
1.10.4 CISC / RISC

RISC et CISC sont des notions différentes pour définir les jeux d’instructions. Elles sont utilisées autant avec les
microprocesseurs qu’avec les microcontrôleurs.
Complex Instruction Set Computer (CISC): Les instructions peuvent être relativement complexes. Une seule
instruction assembleur est subdivisée en une séquence de micro instructions. L’exécution d’une instruction
nécessite donc plusieurs cycles d’horloge. Le micro programme est intégré par le fabricant. Par conséquent,
l’utilisateur n’y a pas d’accès.
Reduced Instruction Set Computer (RISC): Les instructions sont relativement simples. Il n’y a pas se micro
instructions et les instructions sont exécutées directement.
1.11 Exemple de famille de microcontrôleur

Les sections suivantes décrivent les familles de microcontrôleur les plus répandues.
Les microcontrôleurs se distinguent par leur puissance de calcul et par leurs modules périphériques tel que :
 Mémoire (ROM / Flash, RAM, EEPROM)
 GPIO
 Timer

 Interface sérielle
 Convertisseur A/D
 PWM
 CAN
 USB
Le Tableau suivant fournit un aperçu des familles de microcontrôleur.
Famille Description brève

8051 La famille 8051 est la famille la plus connue et la plus répandue des contrôleur 8 bits.
Plusieurs fabricants fournissent des dérivées de ce microcontrôleur, qui se distinguent par
leurs modules périphériques. Le 8031 d’INTEL est considéré ici comme le précurseur.
PIC Le PIC est une famille de contrôleur de 8, 16 et 32 bits de Microchip. Il est utilisé avant tout
dans les applications à bas prix et à basse consommation.
68HCxx Les familles 8 bits de Motorola 68HC05, 68HC08 et 68HC11 sont très répandues dans
l’industrie et dans l’enseignement. Cependant, elles ne sont plus très utilisées dans les
nouvelles applications.
MC683xx Le contrôleur 32 bits de Motorola se base sur la CPU32. Les registres de la CPU ont une
largeur de 32 bits. En fonction du contrôleur, le bus de données peut contenir 16 à 32 bits et
le bus d’adresse 24 à 32 bits. Ces contrôleurs sont utilisés pour des applications, qui
nécessitent des puissances de calcul moyennes, comme la télécommunication et l’industrie
automobile. La famille est construite de façon modulaire et contient plusieurs membres.
Cette famille est remplacée dans les nouvelles applications par celle du ColdFire.
ColdFire La famille des ColdFires remplace celle des MC683xx de Motorola. ColdFire est un
processeur de 32 bits pur, c. à d. qu’il contient des bus d’adresse et de données de 32 bits.
Les processeurs ColdFire possèdent la même architecture que ceux 683xx. Toutefois, ils
sont plus puissants que leurs prédécesseurs.
ARM La société ARM propose des cœurs divers, qui sont fabriqués sous licence par différentes
compagnies. ARM est une abréviation pour Advanced RISC Machine. Actuellement les
familles ARM7 et ARM9 (tous deux à 32 bits) sont très répandues dans le domaine des
contrôleurs embarqués. Ces contrôleurs fournissent une bonne puissance de calcul pour une
consommation relativement basse.
MSP430 Le MSP40 est une famille de contrôleur du type RISC à 16 bits, produite par TI. Il est
utilisé avant tout dans les applications à consommation ultra basse (ex. les appareils à
batteries).
AVR, SAM Différentes familles de contrôleur de la compagnie Atmel comme AVR (processeur 8 bits
RISC), AVR32 (architecture 32 bits avec un DSP et la fonctionnalité SIMD) ou AT91SAM
(contrôleur très bon marché qui se base sur l’architecture ARM7). Ces contrôleurs ont une
grande croissance dans le domaine de l’électronique embarqué.
Tableau 3 : Différents familles de microcontrôleur
1.12 Les critères pour le choix d'un microcontrôleur

Plusieurs critères jouent un rôle plus ou moins important dans le choix d’un processeur. Le poids de ces critères
peut varier en fonction du projet :
 Puissance de calcul (MIPS, FLOPS)
 Largeur de bus (Bus de données et d’adresse, registres CPU)

 Consommation électrique
 Prix
 Disponibilité de deuxième source
 Composants périphériques (Timer, UART etc.)
 Carte d’évaluation et support du développement
L’expérience du développeur et la disponibilité d’environnement de développement et de test jouent souvent un

rôle non négligeable.

Informatique 3 Le microcontrôleur STM32F407
2 Le microcontrôleur STM32F407
La première partie de ce chapitre traite les différentes versions de l’architecture ARM. La seconde partie décrit le
digramme de block et la structure des registres du microcontrôleur STM32F407 de Intel. Ce chapitre ne se limite
toutefois qu’aux aspects généraux, qui sont nécessaires à la programmation de ce dernier. De plus amples
informations sont fournies dans les manuels d’utilisation [ARM_ArchRefMan] à [Cortex-M4_Devices] ou la
littérature spécialisée [Sloss_SysDevGuide] ou [Furber_SoCArch]
2.1 L’architecture ARM

Les processeurs ARM ont été développés (entre 1983 et 1985) par la société Acorn Computers Limited à
Cambridge (Angleterre). C’était la première utilisation commerciale d’un processeur RISC. La société ARM
Limited (Advanced RISC Machines Limited) a été créée en 1990, afin de continuer de développer cette
technologie.
Les microprocesseurs, qui sont basés sur l’architecture ARM, sont actuellement très répondus. Les raisons en
sont multiples :
 Architecture commune
 Puissance de calcul élevée
 Faible consommation (typiquement moins d’un Watt)
 Coût réduit
Les domaines d’utilisation sont les suivants :

 Les systèmes embarqués (téléphone mobile, PDA, commandes)
 Les applications en relation avec la sécurité
 Plateforme pour différents systèmes d’exploitation
Les caractéristiques les plus importantes de l’architecture ARM sont les suivantes :
 Les caractéristiques typiques de l’architecture RISC :
 Un grand banc de registre à 32 bits
 Architecture « Load / Store ». Le traitement de données ne peut être effectué que sur les
registres. Les données, qui sont stockées dans de la mémoire, ne peuvent pas être traitées par la
CPU.
 Les instructions sont orthogonales
 Adressage simple à l’aide des registres standard
 Trois formats d’adressage
 La longueur des instructions est fixe (32 bits). Ce qui simplifie le décodage des instructions.
 Les propriétés typiques de l’architecture ARM :
 Une instruction unique permet d’utiliser l’ALU avec le « barrel shifters » (shift left / right)
 Incrémentations et décrémentations automatiques des différents modes d’adressages
 Opérations « Load / Store » simultanées pour plusieurs registres
 Exécution conditionnelle des instructions (conditional execution)
 Les types de données byte (8 bits), halfword (16 bits) et word (32 bits)
 Les jeux d’instructions ARM à 32 bits, Thumb à 16 bits et Jazelle. Ce dernier est prévu pour
l’exécution du code byte Java
 L’ARM possède un système de traitement des interruptions simple et efficace pour les types
d’exception suivants :
 16 exceptions au niveau du système : Reset, NMI, HardFault, MemManage, BusFault,
UsageFault, SVCall, PendSV et SysTick
 Jusqu’à 240 exceptions au niveau application (interruptions hardware)
 Les registres d’état : L’état actuel du processeur est stocké dans le registre d’état du programme
(Program Status Register: PSR) (voir chapitre 2.5.1) :

 4 bits d’état
 9 bits pour le numéro de l’exception, qui est actuellement traitées
 1 bit pour le mode ARM ou Thumb
ARM propose plusieurs versions d’architecture. Les nouvelles versions sont compatibles avec les anciennes. Ces
dernières mettent à disposition de nouvelles instructions et de nouvelles fonctionnalités hardware. Chaque
version d’architecture est déclinée en différentes familles, qui à leur tour possèdent différents cœurs (Core). Le
Tableau 4 fournit un aperçu de ces dernières.
Divers familles de processeur ARM sont proposées pour une version d’architecture donnée (Par exemple :
ARM7, ARM9, ARM10 etc.). Au sein d’une famille il existe plusieurs cœurs (Par exemple : ARM7TDMI,
ARM740T). La nomenclature pour ces derniers est la suivante :
ARM{x}{y}{z}{T}{D}{M}{I}{E}{J}{F}{S}
x: Famille
y: Gestion de mémoire / unité de protection
z: Mémoire cache
T: Décodeur d’instruction Thumb à 16-bit
D: Débuggeur JTAG
M: Multiplication rapide
I: Embedded ICE Macrocell
E: Instruction améliorée
J: Jazelle (code byte Java)
F: Unité à virgule flottante vectorielle
S: Version synthétisable
Tous les cœurs, qui ont été développés après l’ARM7TDMI, contiennent les fonctionnalités TDMI.
Aujourd’hui il existe beaucoup de fournisseur de technologie silicium, qui possèdent des licences du cœur ARM
et qui les implémentent dans leur microcontrôleur. Voici un aperçu de ces fabricants : Analog Device, Atmel,
Freescale, Infineon, Intel, NEC, Philips, Samsung, TI et Toshiba.

Architecture Brève description Famille / Cœur

ARM
v1 (1983) Première version de l’architecture ARM de Acorn Computers, ARM1
basée sur la CPU 6502.
Adressage à 26 bits
Pas de multiplication et de coprocesseur
v2 Premier chip commercial, ARM2
Adressage à 26 bits, bus de données à 32 bits, multiplication
fournissant un résultat à 32 bits,
architecture simple : 30'000 transistors, basse consommation, v2
ne possède pas de mémoire cache, v2a est la première version
avec une mémoire cache,
soutient le coprocesseur
v3 (1991) Première version d’ARM Limited. ARM6, ARM600,
Processeur indépendant ou intégré dans un CPU en tant que ARM610,
cellule macro. ARM7, ARM700,
On-Chip-Cache, MMU, adressage à 32 bits, les registres CPS et ARM710
SPS sont séparés.
35'000 transistors.
La version V3M soutient les instructions « Multiply-
Accumulate », fournissant un résultat de 64 bits.
v4 La plus vieille architecture ARM, qui est encore soutenue StrongARM, ARMS,
aujourd’hui. ARM810
Nouvelle instructions pour charger et stocker des demi-mots
signés et non signés (16 bits) ainsi que des bytes signés.
Introduction du mode système.
V4 possède pour la première fois d’une définition formelle.
v4T Nouveau format comprimé à 16 bits (Thumb) des jeux ARM7TDMI,
d’instruction. ARM710T, ARM740T,
ARM9TDMI,
ARM920T, ARM940T
v5TE (1999) Amélioration des instructions Thumb. XScale,
Nouvelles instructions, comme par exemple BLX, CLZ et BRK. ARM9E-S,
Extension du jeu d’instructions pour le traitement du signal ARM10TDMI,
(support DSP) de la version E, comme par exemple les ARM1020E
instructions à cycle unique 16* 16 et 16* 32 MAC.
v5TEJ (2000) Introduction de la technologie Jazelle, pour exécuter de façon ARM926EJ,
optimale le code byte Java. ARM1026EJ
Cela est plus rapide qu’une machine virtuelle Java (Java Virtual
Machine) implémenté en software.
v6 (2001) Soutient des environnements multiprocesseurs. Instructions ARM1136J,
multimédia qui soutiennent le SIMD, comme par exemple le ARM1156T2
MPEG4.
TrustZone: partage de l’espace d’adressage physique dans une
partie sure et un partie non sure.
6 nouveaux bits d’état (GE [3:0], bit E, bit A).
v7 Trois profils de processeur sont soutenus : Coretex-M3, Coretex-R4,
A : Les applications pour utilisateur générales Coretex-A8
R : Système temps réel
M : Serial Wire Debug (SWD) pour les microcontrôleurs et les
applications bas coûts, afin de réduire le nombre de Pins.
Version améliorée du jeu d’instruction Thumb.
Tableau 4 : Aperçu des architectures ARM

2.2 Le processeur Cortex-M4

2.2.1 L’architecture du processeur Cortex-M4
Le processeur Cortex M4 est basé sur l’architecture ARMv7. Le schéma bloque de la Figure 39 illustre les
principaux composants de la microarchitecture.
Figure 39 : Architecture du Cortex M4, source : [ARM_Cortex-M4_Processor_TechRefMan]

La microarchitecture du Cortex M4 possède en supplément du Cœur d’exécution, qui sera décrit dans le chapitre
2.2.2 de façon plus détaillée, les composants suivants :
 Bus Matrix: La matrice du système de bus connecte le processeur et l’interface de débogage aux
systèmes de bus externes suivants :
 ICode Interface Bus (32 Bit). Ce bus charge (fetch) les instructions/vecteurs qui sont stockés
dans la zone d’adressage du programme (0x0000_0000 à 0x1FFF_FFFF).
 DCode Interface Bus (32 Bit). Ce bus lit/écrit les données qui sont stockées dans la zone
d’adressage du programme.
 System bus (32 Bit). Ce bus est destiné pour charger les instructions/vecteurs ainsi que la
lecture et l’écriture des données, qui sont stockés dans la zone d’adressage du système
(0x20000000 à 0xDFFFFFFF et 0xE0100000 à 0xFFFFFFFF).
 PPB (32 Bit): Ce bus est prévu pour la lecture et l’écriture des données dans la zone
d’adressage privée (0xE004_0000 à 0xE00F_FFFF) afin de pouvoir tracer le
comportement du logiciel avec un analyseur de signaux.
 Nested Vectored Interrupt Controller (NVIC): Le NVIC est un contrôleur d’interruption embarqué,
qui permet de traiter les interruptions avec un temps de latence très réduits. Le NVIC met à disposition
16 exceptions systèmes et 240 canaux d’interruption hardware. Il propose 256 niveaux d’interruption et
contient une interruption non masquable (NMI).
 System Timer (SysTick): Le SysTick est une horloge 24 Bit, qui peut être utilisé comme horloge du
« système d’exploitation temps réel » (RTOS) ou comme un compteur standard.
 Optional Memory Protection Unit (MPU): La MPU augmente la fiabilité du système à l’aide
d’attributs de mémoire pour les différents zones de stockage.
 Optional Floating-Point Unit (FPU): La FPU réalise des opérations à virgule flottante de simple
précision qui sont compatibles au standard IEEE754 (32 bit float).
 Optional Wakeup Interrupt Controller (WIC): Le WIC est un composant périphérique en option qui
est capable de détecter certains signaux d’interruption afin de réactiver le processeur à partir du mode
veille.
 Optional Instrumentation Trace Macrocell (ITM): L’ITM est une source de signaux de traçage, qui
fournit des informations concernant le système d’exploitation et les évènements de l’application.
 Optional Embedded Trace Macrocell (ETM): L’ETM permet de tracer les instructions afin de
pouvoir réaliser un suivi complet des instructions durant la phase de débogage.
 Optional Trace Port Interface Unit (TPIU): Le TPIU rassemble les données d’ITM et d’ETM en un
seul flux de données, qui peuvent être envoyé à un analyseur de signaux.
 Optional AHB Access Port (AHB-AP): Le processeur peut contenir une interface AHB-AP pour le
débogage. Dans ce cas, un port de débogage peut être connecté à cette interface. Le Cortex-M4 les
formats de port de débogage suivants :
 JTAG
 Serial Wire
 JTAG (Joint Test Action Group) est une interface de débogage standard.
 Serial Wire (SW): Le SW permet d’exporter les messages générés par le logiciel, les données
enregistrées et les informations concernant le profil de façon sérielle à l’aide d’un seul pin. Cela permet
un débogage similaire aux appels printf() sans devoir implémenter une interface UART, USB ou
Ethernet.
 Optional Debug Access Port (DAP): Le DAP permet au débogueur externe d’accéder à l’ensemble des
zones mémoires du système sans devoir commuter le processeur en mode débogage. Cela est
spécialement utile pour accéder aux registres durant les phases de transition ou dans le mode basse
puissance.

2.2.2 Le cœur d’exécution du Cortex-M4

La Figure 40 illustre le transfert des données au sein du cœur d’exécution.
Le traitement des données au sein du cœur du Cortex-M4 s’effectue toujours à l’aide de registres. Il n’existe pas
d’instruction, qui soit capable de traiter directement de contenu de la mémoire. Les données sont donc
transférées dans le banc de registres, qui est composé de 16 registres de 32 bits.
La plupart des instructions ARM interprètent le contenu des registres comme des valeurs entières 32 bits
(signées ou non signées). L’unité « Sign extend » permet de convertir les valeurs signées 8 et 16 bits, qui ont été
lues à partir de la mémoire externe, en des valeurs signées 32 bits.
La plupart des instructions ARM traite deux opérandes (Rn et Rm). Le contenu de ces registres est transférer
avec les bus internes A et B. Le second opérande Rm peut être également décalé, soit vers la gauche ou vers la
droite, avec le « Barrel Shifter ».
L’ALU (Arithmetic Logic Unit) ou le MAC (Multiply Accumulate Unit) traitent les opérandes Rn et Rm, et
écrivent le résultat dans le registre (Rd).
Les instructions Load / Store permettent de transférer les données, soit à partir de la mémoire externe dans un
registre, ou inversement à partir d’un registre dans la mémoire externe. L’adresse de la case mémoire à
sélectionner est calculée par l’ALU. Cette dernière est copiée dans le registre d’adresse, afin d’être fournie sur le
bus d’adresse. L’incrémenter (Incremented) permet d’incrémenter ou de décrémenter cette adresse, après chaque
opération d’écriture et de lecture.
Data
Sign extend
Write Read
r15 (PC) Registerbank Rd

r0 – r15
Rn Rm B-Bus
A-Bus
Barrel shifter
A B Acc
ALU MAC
Result-Bus
Address register
Incrementer
Address
Figure 40: Le transfert des données au sein du cœur ARM, source : [Sloss_SysDevGuide]

2.2.3 Le pipeline des instructions du Cortex-M4

Les instructions à exécuter sont stockées dans un pipeline dans la plupart des processeurs. Le pipeline permet
simultanément d’exécuter l’instruction courante et de charger l’instruction suivante. Toutefois le pipeline
présente un désavantage avec les sauts de programme conditionnels. Dans ce cas, il faut systématiquement vider
le pipeline, lorsque le comportement du programme a été mal prédit.
Le Cortex-M4 contient un pipeline à 3 étages qui sont les suivantes :

1) Fetch: Lecture de l’instruction à partir de la mémoire programme.
2) Decode: Identification de l’instruction à exécuter.
3) Execute : Exécution de l’instruction à exécuter
Les trois étages du pipeline doivent être exécutés pour chaque instruction. L’exécution de chaque étage nécessite
un cycle d’horloge. Par conséquent, l’exécution d’une instruction complète nécessite trois cycles d’horloge. Ce
système permet toutefois d’exécuter une instruction par cycle d’horloge, car le pipeline traite simultanément
plusieurs instructions. L’exemple suivant illustre ce procédé :
Fetch Decode Execute
Cycle 1 Instr. 1
Cycle 2 Instr. 2 Instr. 1

time
Cycle 3 Instr. 3 Instr. 2 Instr. 1
Figure 41 : Exemple de pipeline à 3 niveaux

Au premier cycle d’horloge, l’instruction 1 est lue à partir de la mémoire programme. Au second cycle
d’horloge, le code d’opération (Opcode) de cette instruction est décode, alors que la prochaine instruction est lue
simultanément. Au dernier cycle d’horloge, l’instruction 1 est exécutée, l’instruction 2 est décodée et
l’instruction est 3 lue.
2.3 Le microcontrôleur STM32F407xx

2.3.1 Les propriétés du STM32F407xx
Les propriétés les plus importantes, héritées des processeurs ARM, sont les suivantes :
 Processeur RISC 32 bits, qui est basé sur l’architecture ARMv7.
 Un grand banc de registre, contenant 16 registres universels et 2 registres d’état. Les registres peuvent
être changés individuellement en fonction du contexte du processeur.
 Pipeline d’instruction à 3 étages
Les propriétés propres à la famille Cortex-M4 sont les suivantes :

 Intégration étroite des périphériques du système afin de réduire la surface et le coût de développement
 Jeu d’instruction thumb qui combine la haute densité d’un code 16 bits avec la performance d’un code
32 bits
 Une unité de calcul à virgule flottante (FPU) avec une précision float
 Mode de veille pour réduire la consommation
 Exécution rapide du programme, ce qui permet de réduire la fréquence d’horloge et d’augmenter les
temps de veille
 Unité hardware pour la division et unité hardware pour la multiplication et l’accumulation (MAC)
 Arithmétique saturée pour le traitement du signal

 Traitement des interruptions à durée déterministique et de haute performance pour les applications
temps réel
 Unité de protection de la mémoire (MPU) pour les applications critiques
 Mise à disposition de nombreux outils de débogage et de traçage. Les signaux de débogage et de traçage
sériels réduisent massivement le nombre de pins nécessaires.
2.3.2 Le diagramme de bloc du microcontrôleur STM32F407xx
Figure 42 : Diagramme de bloc du microcontrôleur STM32F40xx,

source : STM32405Fxx-407xx [STM32F407xx_Datasheet]
Le microcontrôleur STM32F40x ajoute au processeur Cortex-M4 du chapitre 2.2.2 des périphériques

supplémentaires. Les composants les plus importants du diagramme de bloc de la Figure 42 sont les suivants :
 Le processeur ARM Cortex-M4 avec les mémoires flash et RAM embarqués, dont les propriétés ont
été décrites au chapitre 2.2.1.
 Power-Management flexible pour divers applications à basse consommation. Fondamentalement trois
modes en sont proposés : Sleep, Stop et Standby.
 Jusqu’à 1 MB Flash
 192 KB de SRAM interne, parmi lesquels 112 KB SRAM, 16 KB SRAM, 64 KB RAM CCM (core
coupled memory) et 4 KB SRAM de backup (4 KB BKPSRAM)
 Multi-AHB Busmatrix. La matrice de bus relie tous les bus maîtres (CPU, DMA, Ethernet et USB HS)
aux bus esclaves (Flash, RAM, FSMC ainsi que le périphériques AHB et APB).
 Nested vectored interrupt controller (NVIC), qui peut gérer jusqu’à 256 niveau de priorités. Le NVIC
peut traiter 16 exceptions au niveau système et jusqu’à 82 canaux d’interruption hardware.
 External interrupt/event controller (EXTI), qui est composé de 23 détecteurs de flanc d’interruptions
ou d’évènements.
 16 minuteries (timer) parmi lesquels :
 2 minuteries de référence pour la génération de signaux PWM (TIM1 et TIM8)
 10 minuteries d’utilité générale avec rechargement automatique (reload), parmi lesquels 4 sont
équipés avec des compteurs vers le haut et vers le bas (TIM2 à TIM5) et 6 seulement avec un
compteur vers le haut (TIM9 à TIM14).
 2 minuteries standards (TIM6 et TIM7) pour la génération de signaux de déclenchement
(trigger)
 2 minuteries watchdog (WWDG).
 Real Time Clock (RTC), backup SRAM and Register. Le RTC est composé fondamentalement d’un
compteur décimal codé binaire (BCD) et des registres dédicacés, qui contiennent les secondes, les
minutes, les heures, le jour de la semaine, le jour du mois, le mois et l’année sous format BCD. Le
SRAM backup et les registres sont utilisés pour stocker les données, qui doivent être conservées dans le
mode VBAT.
 General Purpose Input/Output (GPIO) : De nombreux pins du STM32F40x sont multifonctionnel et
peuvent être utilisés comme entrée/sortie numérique.
 External Memory Controller (FSMC). Le FSMC commande les bus d’adresse, de données et de
control externes et il supporte les technologies de stockage suivantes : PCCard/Compact Flash, SRAM,
PSRAM, NOR et NAND Flash.
 2 Direct Memory Access Controller (DMA1 et DMA2) pour les transferts de données de mémoire à
mémoire, de périphérique à mémoire et de mémoire à périphérique.
 De nombreuses interfaces sérielles comme par exemple :
 4 USART (USART1, USART2, USART3 et USART6)
 2 UART (UART4 et UART5)
 Jusqu’à 3 bus I2C (I2C1 à I2C3)
 Jusqu’à 3 SPI (SPI1, SP2 et SP3)
 Jusqu’à 2 I2S standards (I2S2 et I2S3)
 Audio PLL I2S (PLLI2S)
 Interface Ethernet MAC
 2 Interfaces CAN (bxCAN1 et bxCAN2), qui soutiennent les standards 2.0A et 2.0B Standards
 USB on-the-go full-speed (OTG_FS)
 USB on-the-go high-speed (OTG_HS)
 Interface Secure digital input/output (SDIO) et MultiMedia-Card (MMC), qui soutient les cartes secure
digital et multimedia.
 Digital Camera Interface (DCMI), qui peut être connecté à travers une interface de 8 ou 14 bits à un
module de caméra ou une sonde CMOS.
 3 convertisseurs A/D (ADC1 à ADC3) avec une précision de 12 Bits. Chaque convertisseur peut gérer
jusqu’à 16 canaux d’entrée.
 Sonde de température qui génère une tension linéaire entre 1.8 et 3.6 volt en fonction de la
température.
 2 convertisseurs D/A (DAC1 et DAC2) avec une précision de 12 Bits.
 Interface de test / débogage

2.4 Les modes de fonctionnement et les niveaux de

privilège
Le processeur Cortex-M4 (comme tous les autres processeurs ARM) supporte différents modes de
fonctionnement et niveaux de privilège. Ces derniers sont décrits dans le Tableau suivant :
Mode de fonctionnement Description

Thread Les applications standards sont exécutées dans ce mode
Handler Les exceptions sont traitées dans ce mode (voir chapitre 7)
Figure 43 : Mode de fonctionnement
Niveau de privilège Description

Non privilégié Le programme :
 n’a qu’un accès limité aux instructions MSR- et MSR (voire
chapitre 2.5)
 ne peut pas accéder au Timer, NVIC et le bloc de contrôle du
système
 n’accède que de façon limitée aux composants de stockages et
périphériques
Les programmes non privilégiés sont exécutés à un niveau non
privilégié.
Privilégié Le programme peut exécuter toutes les instructions et accéder à toutes
les ressources.
Figure 44 : Niveau de privilège
Dans le mode Thread, le bit [0] du registre CONTROL qui permet de spécifier, si le programme doit être exécuté
au niveau privilégié (bit [0] = 0) ou non privilégié (bit [0] = 1). Dans le mode Handler, le programme est
toujours exécuté au niveau privilégié.
Dans le mode Thread, seul un programme privilégié peut accéder au registre de contrôle afin de modifier le
niveau de privilège. Les programmes non privilégiés doivent alors réaliser un appel superviseur avec
l’instruction SVC afin de remettre à nouveau le niveau privilégié.
2.5 Le modèle des registres

Les registres constituent l’interface entre le programmeur et le processeur. Le set des registres ARM comprend
les registres suivants (voir Figure 45) :
R0 – r15 16 registres d’utilités générales de 32 bits, destinés au stockage des données et des adresses.
Les trois derniers registres de ce set sont utilisés normalement pour des tâches spéciales :
 R13 en tant que « stack pointer » (SP), contient l’adresse actuelle de la pile du
mode momentané
 R14 en tant que « link register » (LR), contient l’adresse de retour dans le cadre
d’appels de sous routine.
 R15 en tant que « program counter » (PC), contient l’adresse de la prochaine
instruction, qui doit être lue (fetch)
PSR Program Status Register, voir chapitre 2.5.1
PRIMASK, Exception Mask Registers, voir chapitre 2.5.3
FAULTMASK &
BASEPRI
CONTROL Registre de control, voir chapitre 2.5.4

Figure 45: Set des registres ARM / Cortex-M4
La CPU peut accéder aux 16 registres d’utilité générale, qui sont désignés ici de R0 à R15, dans les deux
niveaux de privilège. Par conséquent, ces registres peuvent être utilisés librement à quelques exceptions près.
Selon la convention, le registre R13 doit être utilisé comme pointeur de pile (SP). Le registre SP se décline en
deux versions : Main Stack Pointer (MSP), qui n’est accessible qu’au niveau privilégié, et le Process Stack
Pointer (PSP), qui est accessible dans les deux niveaux de privilège. Dans le mode Thread, le bit [1] du registre
de CONTROL permet de spécifier le pointeur de pile, qui doit être utilisé :
 Bit [1] = 0  MSP, qui est utilisé après le reset
 Bit [1] = 1  PSP
Le registre R14 est également appelé registre de lien (LR). Ce dernier contient l’adresse de retour lors d’un appel
de sous routine. Les deux niveaux de privilège permettent d’accéder à LR.
Le registre R15 contient le compteur de programme (PC). Les deux niveaux de privilège permettent d‘accéder
au registre PC. Durant la phase de reset, la valeur de son vecteur (qui est stockée à l‘adresse 0x00000004 dans
la mémoire) est chargée dans le registre PC. Cette valeur est l’adresse de départ du programme, qui doit être
exécuté par le processeur.
L’utilisation des registre est spécifié plus précisément par le standard APCS (ARM Procedure Call Standard),
voir également le chapitre 6 Les sous routines.
2.5.1 Program Status Register (PSR)

Ce registre permet de lire ou de modifier l’état actuel du processeur. Les bits et les drapeaux (flags) sont définis
de la manière suivante :
 Les bits de condition (Condition flags) : N, Z, C, V, Q
 Le numéro de l’exception ou interruption qui est actuellement traitée par le processeur (ISR_NUMMER)
 Le bit d’état du processeur (T), qui permet de spécifier le jeu d’instructions à exécuter : ARM à 32 bit

ou thumb à 16 bits. Attention le processeur Cortex-M4 ne peut exécuter que du code thumb.
Le registre PSR est en fait une combinaison de trois registres :

 Application Program Status Register (APSR), qui contient les bits de condition. L’APSR est accessible
en écriture et en lecture avec les deux niveaux de privilège.
 Interrupt Program Status Register (IPSR), qui contient le champ de bits ISR_NUMMER. L’IPSR n’est
accessible en lecture qu’au niveau privilégié.
 Execution Program Status Register (EPSR), qui contient le bit T. L’EPSR n’est accessible en écriture et
en lecture qu’au niveau privilégié.
Ces registres possèdent de champs de bits qui s’excluent mutuellement en formant ensemble le registre PSR
(voir Figure 46)
Figure 46 : Program Status Register
Les registres PSR peuvent être utilisés de façon isolé ou combiné avec les instructions MSR ou MRS (voir
chapitre 4.3.7). Die Tableau 5 illustre les différentes possibilités de combinaison pour l’utilisation des registres
d’états.
Nom de registre Combinaison

PSR APSR, IPSR et EPSR
IEPSR EPSR et IPSR
IAPSR IPSR et APSR
EAPSR EPSR et APSR
Tableau 5: Combinaison des Registres PSR

2.5.2 Les bits de condition

Les bits de condition (Condition Flags) sont modifiés par l’ALU en fonction des instructions de comparaison ou
des instructions arithmétiques définies avec le suffixe S. Une soustraction (instruction SUBS) met par exemple le
bit Z (Zero) a un, lorsque le résultat de l’opération et nul.
Les sauts de programme conditionnels sont toujours réalisés en fonction des bits de condition. Si le programme
contient par exemple l’instruction « if (A == 0) », il exécutera un saut conditionnel en fonction de la valeur
du bit de condition Z. Les processeurs ARM permettent également d’exécuter les instructions conventionnelles
de façon conditionnelle à l’aide des bits de condition (Conditional Execution).
Le Tableau suivant contient les bits de condition du registre APSR ainsi que leur description :
Bit de Nom du bit de Description

condition condition
N Negative Le bit N correspond au signe des nombres. Ce dernier est mis à un (1) avec les
nombres négatifs, et il est mise à zéro (0) avec les nombres positifs.
Z Zero Le bit Z est mis à un lorsque le résultat de l’opération ALU est nul. Cela est
également valable pour les comparaisons de nombres : Le bit Z est mis à un
lorsque deux nombre sont égaux.
C Carry Avec les additions, le bit C est mis à 1 lorsqu’il y a un dépassement de
capacité non signé, sinon il reste à 0 (voir Figure 47).
Avec les soustractions, le bit C est mis à 0 lorsqu’il y a un dépassement de
capacité non signé, sinon il reste à 1 (voir Figure 47).
Avec les opérations de décalage, le bit C contient la valeur du dernier bit de
l’opérande.
V oVerflow Avec les additions et les soustractions, le bit V est mis à un lorsqu’il y a un
dépassement de capacité signé (voir Figure 48).
Q saturation Ce bit Q est mis à 1 par les instructions arithmétiques de saturation (QADD,
QDADD, QSUB, QDSUB etc.) lorsque des dépassements de capacité singés ont
lieu (saturation). Le résultat est alors soi la valeur positive la plus grande ou la
valeur négative la plus petite. Ce bit Q n’est disponible que dans certains cœurs
(ex. v5TE).
Tableau 6 : Les bits de condition

Do maine des nombres

0 232 - 1
Dépassement avec Nulle Dépassement avec

Soustraction addition
C=0 C=1
32 0 1
(2 ) -1
32 2
(2 )
SUB ADD
231
Figure 47 : Cercle de nombres binaires non signée
Domaine des nombres

- 231 231 -1
Nulle
0
-1 1
2
N=1 N=0
SUB Négatif Positif ADD
- 231 - 1 231
V=1 V=1
Dépassement avec Dépassement avec
addition soustraction
Figure 48 : Cercle de nombres binaires signés
2.5.3 Exception Mask Registers

Les registres de masquage d’exceptions permettent de désactiver momentanément le traitement des exceptions,
afin d’éliminer leur impact sur le traitement des tâches à temps critique (voir chapitre 7). Les instructions MSR et
MRS permettent d’accéder à ces registres au niveau privilégié.
Le registre de masquage de priorité (PRIMASK) empêche le traitement des exceptions, dont la priorité est
configurable (voir le tableau des propriétés des exceptions en annexe C). Cela représente tous les exceptions mis
à part le Reset, l’interruption non masquable (NMI), qui peut être généré par certains périphériques ou par le
logiciel lui-même, et HardFault, qui est généré par les erreurs survenant durant le traitement des exceptions.
L’affectation des bits du registre PRIMASK est la suivante :

Figure 49 : Registre PRIMASK
Bit Nom Fonction

[31:1] - Réservé
[0] PRIMASK 0 = pas d’effet
1 = empêche le traitement des exceptions dont la priorité est configurable
Tableau 7 : Affectation des bits du registre PRIMASK
Le registre de masquage par défaut (FAULTMASK) empêche le traitement de toutes les exceptions, excepté
l’interruption non masquable (NMI). L’affectation des bits du registre FAULTMASK est la suivante :
Figure 50 : Registre FAULTMASK
Bit Nom Fonction

[31:1] - Réservé
[0] FAULTMASK 0 = pas d’effet
1 = empêche le traitement de toutes les exceptions sauf NMI
Tableau 8 : Affectation des bits du registre FAULTMASK
Le registre de priorité de base (BASEPRI) défini la priorité minimale pour le traitement des exceptions. Lorsque
la valeur du registre BASEPRI est différente de zéro, le traitement des exceptions dont la priorité est égale ou
plus petite que cette valeur sera bloqué. L’affectation des bits du registre BASEPRI est la suivante :
Figure 51 : Registre BASEPRI
2.5.4 CONTROL-Register
Le registre de CONTROL permet de spécifier le niveau de privilège et la pile (stack) à utiliser dans le mode
Thread. Lorsque une FPU est disponible, ce registre indique si le contexte de cette dernière est active ou pas.
L’affectation des bits du registre CONTROL est la suivante :

Bit Nom Fonction

[31:3] - Réservé
[2] FPCA Lorsque la FPU est implémentée, indique si le contexte de cette dernière est actif ou
pas :
 FPCA=0 : Le contexte de la FPU n’est pas actif
 FPCA=1 : Le contexte de la FPU est actif
Le Cortex-M4 utilise ce bit afin de déterminer s’il faut également sauvegarder le
contexte de la FPU (comme par exemple les registres à virgule flottantes) durant les
traitements des exceptions.
[1] PSSEL Spécifie le pointeur de pile (stack pointer), qui est utilisé actuellement dans le mode
Thread :
 PSSEL=0 : MSP
 PSSEL=1 : PSP
[0] nPIV Niveau de privilège dans le mode Thread :
 nPIV=0 : privilégié
 nPIV=1 : non privilégié
Tableau 9: Affectation des bits du register de CONTROL
2.6 Les modèles de mémoire et les formats de

données
Dans les processeurs de la famille ARM, le stockage des données s’effectue par défaut avec le format petit
boutiste (little-endian). Les bytes de poids plus faible des variables sont ainsi stockés en premier, suivis par les
bytes de poids plus fort. Mais les processeurs ARM peuvent être configurés, afin que les données soient stockées
avec le format gros boutiste (big-endian). Nous nous limiterons dans ce chapitre au format petit boutiste.
Les processeurs ARM - à partir de la version v4 - soutiennent les formats de données suivants :
 Byte signés et non signés (8 bits, char)
 Demi-mot (half word) signés et non signés (16 bits, short int)
 Mot (word) signés et non signés (32 bits, long int)
Les processeurs ARM sont basés sur l’architecture Load/Store. C'est-à-dire que les opérandes de l’ALU doivent
toujours être stockés dans des registres. Les opérateurs de l’ALU traitent ainsi les données sous formant mot (32
bits). Les seules instructions, qui sont capables de transférer des données entre la mémoire et les registres, sont
les instructions de transfert de donnée (Load et Store). Ces instructions sont capables de transférer des données
du type byte, demi-mot et mot. Lorsqu’une donnée du type byte ou demi-mot est lue à partir de la mémoire, elle
est étendue à 32 bits avec l’unité d’extension de signe « Sign Extend » (voir Figure 40).
Certaine conditions doivent être respectées pour le stockage des données dans la mémoire. Les Figures suivantes
illustres le stockage des bytes, des demi-mots et des mots dans la mémoire :
Model de mémoire avec un adressage du type byte :
Adresse
N Byte 0
n+1 Byte 1
n+2 Byte 2
n+3 Byte 3
Figure 52: Model de mémoire du type byte

Model de mémoire avec un adressage du type demi-mot :
Adresse
n Demi-mot 0 Byte de poids plus faible du demi-mot 0
Byte de poids plus fort du demi-mot 0
n+2 Demi-mot 1 Byte de poids plus faible du demi-mot 1
Byte de poids plus fort du demi-mot 1
Figure 53: Model de mémoire du type demi-mot
Un demi-mot est toujours stocké à une adresse paire (frontière 2 bytes). Le byte de poids plus faibles sera stocké
à l’adresse inférieure (paire), et le byte de poids plus for à l’adresse supérieur (impaire). Le bit de poids le plus
faible de l’adresse de base A0 est donc nul.
Model de mémoire avec un adressage du type mot :
Adresse
n Mot 0 Byte de poids le plus faible du mot 0
Byte de poids le plus fort du mot 0

n+4 Mot 1 Byte de poids le plus faible du mot 1
Byte de poids le plus fort du mot 1

Figure 54: Model de mémoire du type mot
Un mot est toujours stocké à une adresse, qui est divisible par 4. Le byte de poids le plus faible du mot est stocké
à l’adresse n, alors que le byte de poids le plus fort à l’adresse n+3. Les deux bits de poids les plus faibles de
l’adresse de base (A0 et A1) sont donc nuls.
2.7 Le plan de mémoire du STM32F407xx

Les registres R0 à R15 et le registre PSR sont accessibles directement. C'est-à-dire que les instructions
assembleur peuvent utiliser ces registres comme opérande. Tous les autres registres (comme par exemple ceux
du GPIO, de l’USB etc.) ne sont accessibles qu’à l’aide du système de bus interne (adresse et données). Chacun
de ces registres possèdent donc sa propre adresse. Le plan de mémoire (Memory map) du processeur illustre les
espaces d’adressage pour les différents groupes de registres.
La Figure 55 illustre le plan de mémoire du STM32F407xx :

Figure 55 : Le plan de mémoire du STM32F407xx, source : [STM32F407xx_Datasheet]
Les bus AHB1 (ARM High-performance Bus 1), AHB2, APB1 (ARM Peripheral Bus 1) et APB2 permettent
d’accéder aux composants périphériques internes (voir Figure 42). Chaque composant périphérique interne est
connecté à un de ces bus, qui possède son propre domaine d‘adressage. Le tableau 10 de la fiche technique du
STM32F407xx [STM32F407xx_Datasheet] fournit de plus amples information à ce sujet.
Le bus AHB3 permet de connecter des composants de stockage externes supplémentaires. 4 blocs de 256 MB
chacun sont mis à disposition dans ce segment. Le bus AHB3 soutient en outre les standards suivants :
PCCard/Compact Flash, SRAM, PSRAM ainsi que les flash NOR et NAND.

2.8 Le plan de mémoire du CARME

Les zones d’adressage des composants périphériques externes (Flash, SDRAM, contrôleur CAN etc.) du kit de
développement CARME ont été ajoutées dans le plan de mémoire de la Figure 55. Par conséquent, certaines
zones d’adressage du kit CARME sont identiques à celles du STM32F407xx. Le contrôleur CAN, qui est
sélectionnable avec CS3 dans CARME, possèdent l’adresse de base 0x6E00_0000.
0xE010_0000 Reserved
0xE000_0000 Cortex-M4 internal periphery
Reserved
0x6E00_0000 CAN controller SJA1000 (CS3)
0x6D00_0000 CARME Extension 2 (CS3)
0x6C00_0000 CARME Extension 1 (CS3)
0x6800_0000 LCD SSD1963 controller (CS2)
0x6400_0000 External RAM (CS1)
0x6000_0000 External Flash (CS0)
0x5006_0C00 Reserved
0x5000_0000 AHB2
0x4008_0000 Reserved
0x4002_0000 AHB1
0x4001_0000 APB2
0x4000_0000 APB1
0x2000_0000 128 Kilo SRAM
0x0800_0000 1 Mbyte Flash (Vector Table)
Figure 56 : Le plan de mémoire du kit de développement CARME

2.9 Le schéma des pins

Le STM32F407xx est produit avec différents boîtiers BGA. Soi avec des pins : LQFP64, LQFP100, LQFP144,
LQFP176 ou avec une rangée de grille de boule (Ball Grid Array: BGA) : UFBGA90 et WLCSP176. Par
conséquent, les connexions peuvent varier en fonction du boîtier. Les pins sont en outre répartis selon leur
fonctionnalité dans différents blocks. La Figure 57 illustre un exemple de répartition des pins :
Figure 57: Le schéma des pins du STM32F407xx, source : [STM32F407xx_Datasheet]

2.10 Connexion des composants Flash et SDRAM

Le contrôleur de mémoire externe (FSMC) commande les bus d’adresse, de données et de control externes et il
supporte les technologies de stockage suivantes : PCCard/Compact Flash, SRAM, PSRAM, NOR et NAND
Flash. La Figure 58 illustre comment une SRAM et un flash OneNAND peuvent être connectés à cette interface.
Figure 58 : SRAM et OneNAND-Flash externes du board d’évaluation STM3220G-EVAL,

source: https://parts.arrow.com/de/reference-design/1D1A7BC19D4BA20C5E1245C3E2C5F230

Informatique 3 La programmation en assembleur
3 La programmation en assembleur
3.1 Introduction
Ce chapitre traite la programmation en assembleur de façon générale. Toutefois, les exemples d’assembleur y
sont définis avec le jeu d’instruction ARMV5TE des processeurs XScale. La syntaxe de l’assembleur s’oriente à
celle de GNU. Cette dernière diffère dans un certain nombre de point par rapport à celles des autres fournisseurs.
L’assembleur est un langage de programmation proche du hardware. Il dépend par conséquent du hardware, c’est
à dire qu’il a été développé pour une famille de processeur bien définie.
Avantage : l’assembleur est optimisé pour le hardware (registre, architecture etc.)
Désavantage : l’assembleur n’est pas portable, c. à d. qu’il ne peut pas être utilisé avec un autre CPU.
Ce chapitre traite les équivalences entre les différents assembleurs.
3.2 Les niveaux des langages de programmation

Un processeur ne comprend que le code machine, qui est toutefois incompréhensible pour l’homme. L’homme
utilise donc des langages de programmation, qui sont plus compréhensible pour lui. Ces derniers sont traduits en
code machine par des assembleurs ou des compilateurs.
La Figure suivante montre les niveaux de langage de programmation possible :
Prend une bouteille de bière dans le Langue naturelle

réfrigérateur
Bière – 1 Pseudo code
Proche du hardware
Bière = Bière – 1; Langage de programmation haut

niveau
Abstraction
LDR r4,beer Assembler
SUB r4,#1
STR r4,beer
0xe59f4020 Code machine
1110’0101’1001’1111’0100’0000’0010’0000
0xe2444001
1110’0010’0100’0100’0100’0000’0000’0001
0xe0802001
1110’0000’1000’0000’0010’0000’0000’0001
Figure 59 : Niveau des langages de programmation
a) La langue naturelle est la plus compréhensive pour l’homme. Elle est malheureusement trop floue et trop
redondante. Elle ne convient donc pas pour la programmation.
b) Le pseudo code est souvent utilisé dans la phase de design. Son niveau d’abstraction est très élevé et il n’est
pas standardisé.
c) Les langages de programmation haut-niveau possèdent également un niveau d’abstraction élevé. Les
compilateurs traduisent ces langages dans des codes machine, dont l’efficacité dépend du langage de
programmation et du compilateur. Les langages de programmation les plus répondus pour les
microprocesseurs sont le C et C++. Les langages de programmation haut niveau sont standardisés (ex. ANSI-
C). Ce qui permet de porter les programmes d’un processeur à un autre, avec plus ou moins d’efforts.
d) Les programmes en assembleur sont très difficilement compréhensibles pour l’homme. Toutefois, les
programmes en assembleur sont plus performants et utilisent mieux les ressources que les programmes haut-
niveau.

3.3 La structure d’un fichier en assembleur

Les points suivants influence la structure d’un fichier assembleur :
 La syntaxe de l’assembleur, qui dépend du processeur
 Les directives de l’assembleur, qui dépendent de l’assembleur
 Les lignes directives de programmation, qui dépendent du fabricant
La Figure suivante montre une éventuelle construction d’un fichier assembleur.
/*************************************************************************
* *
* Projet : NomProjet *
* *
* *
**************************************************************************
* Programme/Module : NomModule *
* Nom du fichier : NomFichier.68k *
* Version : 1.00 *
* Définition : dd.mm.yyyy * Entête (header)
* Auteur(s) : NomAuteur * (en option)
* -----------------------------------------------------------------------*
* Description : Description brève du module *
* *
**************************************************************************
* Modification: *
* Auteur Date de la modification *
* m.n dd.mm.yyyy *
*************************************************************************/
/************************************************************************* Interface du
* PUBLIC DECLARATIONS * module
*************************************************************************/
(en option)
.global mysub @ exported subroutines
/************************************************************************* Symbole importé

* EXTERNAL DECLARATIONS (optional) *
(en option)
*************************************************************************/
.extern extsuB @ imported subroutines
/************************************************************************* Fichier à inclure

* include DEFINITIONS *
(en option)
*************************************************************************/
.include ″pxa270.h″ @ include controller registers
/************************************************************************* Définition EQU

* EQUATE DEFINITIONS *
(en option)
*************************************************************************/
.equ MAX,0x1000 @ maximum allowable size
/************************************************************************* Définition des

* VARIABLE AND CONSTANT DEFINITIONS * variables et des
*************************************************************************/ constantes
.data
(en option)
myvar: .space 4 @ space for 1 Word (32-Bit)
/************************************************************************* Code
* CODE *
*************************************************************************/
.text

mysub: ADR r0, myvar @ Load the address of myvar

MOV r1, #MAX @ Load the constant value MAX
STR r1, [r0] @ Copy the MAX value in to myvar
BL Extsub @ Call the subroutine Extsub
MOV pc, lr @ Return to the calling function of mysub
.end
Figure 60 : Construction possible d’un fichier assembleur
Les entêtes (Header) dépendent de la société. Il existe normalement dans les sociétés des lignes directives pour la
programmation, qui définissent l’aspect de l’entête. L’entête devrait toutefois contenir au minimum les
informations suivantes :
 Nom du projet
 Brève description du module
 Historique
La partie « PUBLIC DECLARATIONS » contient tous les noms de sous-routines et de variables, qui sont
définies dans le module courant et doivent être exportées dans les autres modules.
La partie « EXTERNAL DECLARATIONS » contient tous les noms de sous-routines et de variables, qui doivent
être importées depuis les autres modules.
Les fichiers, qui contiennent la description des registres du contrôleur, peuvent être importés dans la partie
« include DEFINITIONS ». include copie tout le contenu du fichier en question dans le module.
La partie « EQUATE DEFINITIONS » contient les définitions EQUATE (correspond à la directive #define
de C).
La partie « VARIABLE AND CONSTANT DEFINITIONS » contient les définitions des variables et des
constantes.
La partie « CODE » contient les instructions du programme. Cette partie est divisée en 4 colonnes (voir chapitre
4.3.1).
3.4 La syntaxe assembleur

3.4.1 La structure d’une ligne assembleur
La syntaxe de l’assembleur, qui également nommé mnémonique, est orientée ligne. Chaque ligne du code source
correspond donc à une instruction assembleur. La Figure suivante illustre un exemple d’instruction assembleur :
Etiquette Opérations / instructions Opérandes Commentaire

main: LDR R0, #MAX @ Max value
Figure 61 : Une ligne d’instruction assembleur
Etiquette :
Le champ des étiquettes commence à la première colonne et se termine avec « : ». L’étiquette peut contenir le
nom d’une variable, d’une sous-routine ou d’un label. Un label est une sorte de marque, qui est utilisé pour les
sauts de programme.
Opération / instructions :
Le champ des opérations / instructions contient les instructions pour la CPU ou les directives pour l’assembleur.
Dans l’exemple ci-dessus « LDR » est une instruction, qui commande à la CPU de copier la valeur constante
« MAX » dans le registre « R0 ».
Toutes les instructions d’un processeur sont définies dans son jeu d’instruction (voir chapitre 4, qui traite le jeu

d’instruction de l’ARM V5)
Toutes les opérations peuvent être exécutées de façon conditionnelle.
Exemple :
CMP r0, #0 @ if (a==0 || b==1)

ITE NE
CMPNE r1, #1
ADDEQ r2, r3, r4 @ c = d + e;
Figure 62 : Instruction assembleur conditionnelle
Ce concept permet d’économiser de nombreux sauts de programme en comparaison avec d’autre famille
d’assembleur. La condition est définie avec un suffixe ou un code de condition à la fin de l’instruction. Par
exemple, le suffixe « NE » de la deuxième comparaison a pour conséquence que cette instruction n’est exécutée
que si le résultat de l’opération précédente est différent de zéro. De la même façon, l’addition n’est exécutée que
si le résultat de l’opération précédente est égal à zéro (EQ).
L’instruction, qui vient d’être exécutée, fixe la condition. Cette dernière est évaluée l’aide des bits d’état courant
du programme (flags), qui se situent dans le registre du même nom (Current Program Status Register abrégé par
PSR). Dans l’exemple de ci-dessus les conditions sont fixées par les deux opérations de comparaisons.
Toutes les opérations arithmétiques, qui sont exécutées par l’ALU, influencent les bits d’état N, Z, C et V. Les
opérations logiques ne modifient que N, Z et C.
Les opérandes :
Les opérandes des instructions ou des directives assembleur sont définis dans le champ des opérandes. Dans
l’exemple de ci-dessus les opérandes de l’instruction « LDR » sont la constante « MAX » et le registre « r0 ».
Le processeur ARM travail fondamentalement avec trois opérandes. Certaines instruction, comme par exemple
les sauts de programme, se limitent à un ou deux opérandes. Le jeu d’instruction ARM ne contient pas
d’instruction sans opérande.
Instruction avec un opérande :

Ce type d’instruction ne possède qu’une adresse de destination. Cette dernière est définie de façon symbolique
avec les ramifications ou les sauts de programme.
Exemple :
B start
SWI 0x10
Instruction avec deux opérandes :

Cette catégorie contient la plupart des instructions de transfert de donnée. Ces dernières stockent / chargent les
données depuis la mémoire de travail dans les registres du processeur
Exemple :
MOV pc,lr
LDR r0,waleur
Les instructions avec trois opérandes :

La plupart des instructions, qui traitent les données, nécessitent trois opérandes. Elles possèdent le formant
suivant :
mnemonic dest, src, shift
Dans cette expression « dest » représente le registre de destination et « src » celui de source. Les registres r0

à r15 peuvent être utilisés pour cela. L’opérande « shift » permet de traiter un opérande à l’aide du « barrel
shifter » avant l’exécution de l’opération. Il permet également de définit un valeur constante de 8 bits.
Chez les processeurs RISC, les instructions de traitement de données ne se limitent en générale à des opérations
entre registres. Les opérations entre des registres et la mémoire de travail sont exclusivement des opérations de
transfert de données.
Les commentaires :
Les commentaires du champ de commentaire sont définis pour améliorer la compréhension du code.
L’assembleur GNU prévoit trois types de commentaires : les commentaires en bloc, les commentaire en ligne et
les commentaire de fin de ligne.
Les commentaires en bloc sont formulés entre « /* » et « */ », comme en ANSI-C. Les commentaires en ligne
sont définis uniquement sur une ligne et ils sont introduits avec un dièse « # ». Les commentaires de fin de ligne
sont défini à la fin de la ligne et ils sont introduits avec un « @ ». Il est très important de bien commenter les
programmes assembleur. Toutefois, le commentaire ne devrait pas décrire l’instruction, mais améliorer la
compréhension du déroulement du programme.
Exemple :
/*
Commentaire de bloc
*/
# Commentaire en ligne
LDR r0,=operand1 @ Commentaire fin de ligne
Figure 63: Les trois formes des commentaires assembleur
3.4.2 Les symboles

Les symboles sont des noms de variables, de sous-routines, de labels etc. Les caractères autorisés pour les
définir sont les suivants :
 Les lettres a à z et A à Z (pas d’accent)
 Les chiffres 0 à 9
 Le caractère de soulignement « _ »
 Le point « . »
 Le caractère dollars « $ »
Les règles suivantes régissent la définition des symboles :

 Le premier caractère ne doit pas être un chiffre.
 Un symbole peut être aussi long que possible, tous les caractères sont significatifs.
 Distinction entre les majuscules et les minuscules.
L’assembleur GNU soutient également les symboles locaux.

Le point unique, en tant que symbole prédéfini, possède une signification précise : Il représente la valeur du
compteur de programme courant. Par exemple « .=.+4 » est équivalent à « .space 4 ».
3.4.3 Les constantes

Les règles suivantes régissent la définition des constantes :

Type Description Préfix Exemple

Chaîne de caractère String " "Bonjour"
Caractère Char ' 'A'
Numérique Hexadécimal 0x 0x7FF
Numérique Binaire 0b 0b0111011
Numérique Octal 0 0124
Numérique Décimal Pas de préfix 123
Tableau 10 : Règles qui régissent la définition des constantes
Les constantes peuvent être spécifié avec le caractère « = ». Cela est valable pour les valeurs numériques et les
adresses, qui sont représentées à l’aide de symbole.
Les valeurs, qui ne peuvent pas être chargées par les instructions « MOV », sont automatiquement adressées de
façon relative avec compteur de programme (ici [pc,#4]). Dans l’exemple suivant, la constante
0x12345678 est chargée de la mémoire programme de cette façon. Par contre, la valeur un est directement
chargée avec l’instruction MOV.
Exemple :
start: LDR r0,=1 @ Charger la valeur
constante 1
loop: LDR r1,=0x12345678 @ Charger la valeur
0x12345678
ADD r0,r0,r1 @ Additionner les deux
valeurs
B loop
A partir du code source de ci-dessus, l’assembleur génère un code objet, dont la structure peut être affichée dans
la fenêtre de désassemblage :
main:
080001dc: ldr r0, [pc, #8] ; (0x80001e8 <main+12>)
080001de: ldr r1, [pc, #12] ; (0x80001ec <main+16>)
080001e0: add r0, r1
080001e2: b.w 0x80001dc ; <main>
Ce code objet sera chargé dans la mémoire de la manière suivante:
Figure 64 : Le code objet correspondant au chargement des constantes 1 et 0x12345678
Remarque :
La valeur constante est stockée à l’adresse 0xA00004F8. Le compteur de programme adresse la prochaine
instruction à exécuter, qui est stockée sous 0xA00004EC. Le chargement des instructions relatif au compteur de
programme, s’effectue toujours avec un décalage préalable de - 8. Ce qui fournit le décalage à noter dans le code
suivant : 0xA00004F8 - 0xA00004EC – 8 = 4.

3.4.4 Les opérateurs et les opérandes

Des calculs peuvent être effectués en dehors de jeu des instructions durant le processus d’assemblage. Ces
calculs sont surtout utilisés pour la détermination des tailles de la mémoire ou des distances des sauts de
programme.
Le Tableau suivant contient les opérateurs, qui sont autorisées dans les expressions assembleur. Des espaces
vides ne sont pas autorisés avant ou après ces opérateurs :
+ Addition
- Soustraction
* Multiplication signée
/ Division signée
% Reste de la division signée (Modulo)
& Opération binaire et
| Opération binaire ou
^ Opération binaire ou exclusive
&& Opération logique et
|| Opération logique ou
==, <> Egalité et inégalité
>, >= Plus grand que, plus grand que ou égale à
<, <= Plus petit que, plus petit que ou égale à
<< Opération de décalage vers la gauche
>> Opération de décalage vers la gauche
- Négation par complément à deux
~ Inversion binaire, complément à un
Tableau 11 : les opérateurs pour les expressions assembleur
La priorité des opérateurs dans les expressions est la suivante :
Négation, complément Priorité maximale

Multiplication, division, modulo
Décalage vers la gauche, décalage vers la droite
Opérations logiques et, ou et ou exclusive
Addition, soustraction
Egalité et inégalité
Opération de comparaison
Opérations booléennes et ou Priorité minimale
Tableau 12 : la priorité entre les différents opérateurs
Le résultat d’une opération de comparaison est toujours un nombre entier dans l’assembleur GNU. La valeur 0
représente faut et la valeur -1 vrai. Les opérations booléenne && et || fournissent par contre une valeur +1,
lorsque le résultat est vrai. Cette différence ne joue aucun rôle pour l’évaluation des conditions, En effet tous ce
qui est différent de 0 est considéré comme vrai.
Exemple:
Les bits 3 et 11 du registre r0 doivent être effacés.
BIC r0, r0, #(1 << 3) | (1 << 11)
L’instruction BIC efface les bits dans le registre r0. Les bits à traiter sont spécifiés avec le paramètre
« #(1 << 3) | (1 << 11) ». La position du bit y est définie avec l’opérande « << », alors que l’opérande « | »
permet d’associer ces derniers.

3.5 L’environnement de développement

Les programmes proches du hardware (Firmware) sont généralement développés sur des PC avec des
environnements de développement intégrés (Integrated Development Environment, IDE). Ces derniers peuvent
être soit simulés ou testés directement sur le hardware (débuggeur). La plupart des environnements de
développement moderne proposent les fonctionnalités suivantes :
 Editeur
 Assembleur, Compilateur et relieur (Linker / Locator)
 Débuggeur
 Gestion de projet
La Figure suivante illustre une vue d’ensemble des fichiers, qui sont générés durant la phase de développement :
Editor
Source Source
assembler
Source C / Source
C++
*.s
assembler *.c
C / C++
*.asm *.s *.cpp*.c
*.asm *.cpp
Assembler Compiler
Listing Fichier Listing Fichier

assembleur
Listing objet
Fichier compilateur
Listing objet
Fichier
*.lst
assembleur *.oobjet *.lst
compilateur *.oobjet
*.list *.ltx*.o *.prn
*.list *.ltx*.o
Linker/Locator
Listing du Fichier Fichier

relieur binaire débuggeur
*.map *.bin *.elf
Figure 65 : Procédure de développement
3.5.1 L’éditeur
L’éditeur permet de définir le code source en assembleur ou avec un langage de programmation évolué. La
plupart des éditeurs sont sensible à la syntaxe et mettent en évidence les mots clés.
Exemple :
Le code en assembleur suivant a été défini à l’aide d’un éditeur.

.arm
.global start
.text
start: LDR r0,=1 @ Load constant value 1

loop: LDR r1,=0x12345678 @ Load constant value 0x12345678
ADD r0,r0,r1 @ ADD both values
B loop
.end
Figure 66 : Exemple d’un code en assembleur
3.5.2 L’assembler
L’assembleur est toujours spécifique à la famille des processeurs. Si vous voulez développer du code pour des
processeurs différents, vous devez également utiliser des assembleurs différents. On parle de « Cross
Assembler », lorsque le code en assembleur est développé sur un ordinateur différent de celui, qui doit exécuter
le programme (ex. l’assembleur fonctionne sur un PC et le code généré sur le microcontrôleur d’une machine à
café).
L’assembleur traduit le code source assembleur, qui est contenu dans un fichier ASCII avec une terminaison
« .s » ou « .asm », en un fichier objet (.o). Des fichiers supplémentaires peuvent être générés, en fonction des
options de l’EDI (ex. fichier de listing : List-File avec une terminaison « .lis »). Le listing de l’assembleur pour
l’exemple ci-dessus a été illustré dans la Figure suivante :
1 2 3
1 # 1 "..\\src\\main.s"
1 .syntax unified
0
0
2 .cpu cortex-m3
3 .fpu softvfp
4 .thumb
5
6 .text
7
8 .global main
9
10
11 main:
12 0000 0248 LDR r0,=1
13 0002 0349 LDR r1,=0x12345678
14
15 0004 0844 ADD r0,r0,r1
16 0006 FFF7FEBF B main
16 00000100
16 00007856
16 3412
Figure 67 : Le listing assembleur
Les colonnes du fichier listing contiennent les informations suivantes :

Nr. de Contenu
colonne
1 Numéro de ligne du code source
2 Adresse relative de départ du code
3 Code machine, par exemple "0000A0E3" veut dire que le registre r0 doit être chargé avec la
valeur 0. "0100080E0" veut dire que le contenu du registre r1 doit être additionné au registre
r0. Toutes les instructions nécessitent 4 bytes (1 mot) de stockage. Elles sont donc stockées à des
adresses mot (divisibles par 4).
reste Code original en assembleur
Tableau 13 : Colonnes du fichier listing
3.5.3 Le compilateur
Comme l’assembleur, le compilateur traduit le programme haut niveau, qui est défini dans un fichier source, en
un fichier objet. Les compilateurs C ou C++ sont utilisés généralement pour les applications embarqués.
3.5.4 Le relieur / locateur

Le relieur (Linker) assemble tous les fichiers objet d’un programme, alors que le localisateur (Locator) attribue
des adresses définitives aux instructions et aux données du programme.
Le relieur / localisateur génère les fichiers suivants :

a) Pour le chargement du code dans la mémoire (.bin) ou
b) Pour le débuggeur (.elf)
c) Fichier de listing et de mappage (.map)
« elf » est une abréviation pour « Executable and Linking Format ». Ce format est un standard pour la gestion
des exécutables, des codes objets des bibliothèques, du mappage de la mémoire et des informations nécessaires
au débuggeur. Le format elf est entre temps très répandu et il a remplacé conceptuellement le COFF et de
nombreux autres formats de débuggeur.
Le contenu de ce fichier ne devrait pas intéresser le programmeur. Il ne peut pas être lu avec l’éditeur, mais par
contre, il peut être exploité avec les applications « objdump.exe » ou « elfdump.exe ».
Figure 68 : Les informations contenues dans le fichier elf exploitées avec OBJDUMP.EXE

3.5.5 Le débuggeur
Le débuggeur permet de tester le code, en représentant le contenu des registres, des variables et du code sur
l’écran du PC. L’insertion de points d’arrêt (break points) dans le code source et son exécution contrôlée, pas par
pas, font partie des exigences minimales pour un débuggeur.
On parle de « target debugging » lorsque le débogage est exécuté directement sur le système en développement.
Dans ce cas le débuggeur, qui est exécuté sur le PC, est responsable du téléchargement du code de débogage sur
le système en développement et de la communication avec ce dernier. Alors que le processeur du système en
développement n’est responsable que de l’exécution de ce code.
3.5.6 La gestion du projet

La gestion de projet permet de gérer les données de manière centralisée :
 Gestion de tous les fichiers du projet (les fichiers sources mais également ceux des bibliothèques et
ceux générés par le projet).
 Définition des chemins du projet (library path)
 Le mappage des segments du programme et des données à des adresses absolues
 Définition des options pour l’assembleur, le compilateur et le relieur
Les environnements de développement modernes (IDE), comme Eclipse ou MS Visual Studio, proposent ces
fonctionnalités.

Informtique 3 Jeu d’instructions du Cortex-M4
4 Jeu d’instructions du Cortex-M4

Ce chapitre traite le jeu d’instructions du processeur Cortex-M4 (c.à.d. les instructions, qui peuvent être
exécutées par la CPU). Pour cela, les instructions ont été réparties dans différents groupes selon leur
fonctionnalité. Une description plus détaillée de ces instructions est fournie par la documentation spécialisée
[ARMv7M_ArchRefMan].
La plupart des processeurs ARMv7 soutiennent les deux jeux d’instructions ARM et Thumb. Les instructions
ARM sont codées de façon uniforme avec 32 bits alors que les instructions Thumb le sont avec 16 bits. Les deux
jeux d’instructions sont équivalents dans leur ensemble. Toutefois le jeu d’instructions Thumb permet une
densité de code plus grande (pratiquement de plus de 50%). Cela apporte de de nombreux cas une amélioration
de la performance. Toutefois les instructions Thumb ne sont pas aussi bien structurées que leur équivalents
ARM. Une description plus détaillé de ces différences est disponibles en annexe D.
Les processeurs Cortex-Mx ne soutient cependant que le jeu d‘instructions Thumb et Thumb-2 (ARMv7-M). Le
second jeu d’instructions est une extension du premier et comprend des instructions à 16 bits mais également à
32 bits, lorsque ces dernières ne peuvent pas être codées avec 16 bits.
Les chapitres suivants traitent uniquement le jeu d’instruction Thumb-2. Les descriptions de l’architecture ARM
et des registres en relation avec ces instructions sont disponibles dans les chapitres 2.4 et 2.5.
4.1 Les instructions

Toutes les 25 instructions de base du processeur sont définies avec des mnémoniques (abréviation d’instruction).
Elles sont obtenues systématiquement des lettres initiales des mots, qui décrivent ces instructions en anglais.
Ex. : ADD, ADd with Carry, Reverse SuBtract, Exclusive OR, BIt Clear,
Les instructions Thumb2 sont codées fondamentalement avec 16 bits. Toutefois, contrairement aux instructions
ARM, les instructions Thumb2 ne possèdent pas de format uniforme. En effet, certaines instructions sont codées
avec 32 bits (p.ex. les sauts de programme lointains, les instructions arithmétiques et logiques conditionnelles,
qui doivent être précédées avec une instruction If-Then).
Cet encodage engendre un certain nombre de restrictions qui ne sont pas très graves dans la pratique :
 Il n’est pas possible de charger des valeurs directes de 32 bits. Mis à part si ces dernières peuvent être
construites avec une valeur (mantisse) de 8 bits et 5 bits de décalage. Toutes les autres valeurs doivent
être chargées directement à partir de la mémoire programme.
 Les instructions saut de programme ne possèdent ne peuvent être réalisées qu’avec un déplacement
relatif (offset) de 24 bits. Les sauts de programme relatifs sont ainsi limités à un espace de  32 MB par
rapport à l’adresse courante. Les sauts de programme absolus de 32 bits sont réalisés avec le
chargement d’une valeur de 32 bits dans le registre du compteur de programme.
 Les instructions Load/Store ne peuvent fonctionner qu’avec un offset de 12 bits. Les accès aux variables
relatifs sont ainsi limités à un espace de 4 KB, par rapport à l’adresse courante.
Le Tableau 14 illustre le jeu d’instruction du processeur ARM :

Informatique 3 Jeu d’instructions du Cortex-M4
Instruction Fonction
ADC Addition de deux valeurs de 32 bits avec la retenue
ADD Addition de deux valeurs de 32 bits
AND Opération logique ET entre deux valeurs à 32 bits
B Saut relatif ± 32 Mégas bytes
BIC Effacer les bits d’une valeur 32 bits
BKPT Point d’arrêt software (break point)
BL Saut avec stockage de l’adresse de retour (appel de sous-routine)
BLX Saut avec stockage de l’adresse de retour et changement de registre
BX Saut avec changement de registre
CDP CDP2 Opération coprocesseur
CLZ Compter les zéros, qui précèdent
CMN Comparaison inversée de deux valeurs 32 bits
CMP Comparaison de deux valeurs 32 bits
EOR Opération logique OU exclusive entre deux valeurs 32 bits
LDC LDC2 Charger le coprocesseur avec une ou plusieurs valeurs 32 bits
LDM Charger plusieurs valeurs de 32 bits depuis la mémoire dans les registres ARM
LDR Charger la valeur avec une adresse virtuelle dans un registre ARM
MCR MCR2 MCRR Charger une ou plusieurs registres ARM dans le coprocesseur
MLA Multiplication et accumulation d’une valeur 32 bits
MOV Charger la valeur 32 bits dans un registre
MRC MRC2 MRRC Charger depuis le processeur dans un ou plusieurs registres
MRS Copier le registre de statut (PSR ou SPSR) dans un registre ARM
MSR Copier depuis le registre ARM dans un registre d’état (PSR ou SPSR)
MUL Multiplier deux valeurs de 32 bits
MVN Charger une valeur 32 bits, préalablement inversée, dans un registre
ORR Opération logique OU entre deux valeurs 32 bits
PLD Indique l’adresse de la case mémoire, qui est en train d’être chargée
QADD Addition signée de deux valeurs 32 bits avec limitation du dépassement de capacité
QDADD Addition signée double de deux valeurs 32 bits et limitation du dépassement de capacité
QDSUB Soustraction signée double de deux valeurs 32 bits et limitation du dépassement de
capacité
QSUB Soustraction signée de deux valeurs 32 bits avec limitation du dépassement de capacité
RSB Soustraction inverse de deux valeurs 32 bits
RSC Soustraction inverse de deux valeurs 32 bits avec la retenu
SBC Soustraction de deux valeurs 32 bits avec retenu
SMLAxy Multiplication/addition signées (16x16)+32 = 32 Bit
SMLAL Multiplication/addition larges signées (32x32)+64 = 64 Bit
SMLALxy Multiplication/addition larges signées (16x16)+64 = 64 Bit
SMLAWxy Multiplication/addition signées ((32x16)>>16)+32 = 32 Bit
SMULxy Multiplication signée (16x16) = 32 Bit
SMULWy Multiplication/addition signées ((32x16)>>16)+32 = 32 Bit
STC STC2 Stocker une ou plusieurs valeurs depuis le processeur dans la mémoire
STM Stocker plusieurs registres ARM dans le processeur
STR Stocker des registres à des adresses virtuelles
SUB Soustraire deux valeurs à 32 bits
SWI Interruption software
SWP Echanger les registres ARM avec la mémoire de façon byte ou mot
TEQ Comparer deux valeurs 32 bits
TST Tester un bit dans un registre 32 bits
UMLAL Multiplication/addition larges non singées (32x32)+64 = 64 Bit
UMUL Multiplication large non signée (32x32) = 64 Bit
Tableau 14 : Jeu d’instruction du processeur ARM à partir de la version v5E.

4.1.1 La syntaxe des instructions ARM

Le processeur ARM est une machine avec trois opérandes. Toutes les instructions, qui traitent les données, ne
travaillent qu’avec des registres.
Syntaxe :
Opcode Rd, Rn {,N}
Le code d’opération est une des instructions du Tableau 14.
Tous les registres de R0 à R15 peuvent être utilisés pour Rd et Rn. L’opérande N permet de pré traiter
facultativement un des opérandes avec le décalage à barilier (Barrel Shifter). N peut être une valeur constante, un
registre ou un registre décalé. L’opération de décalage ne modifie pas le contenu du registre source. Toutes les
valeurs constantes ne sont toutefois pas admises, car ces dernières ne peuvent être composées que de valeurs 8
bits décalées dans un registre 32 bits. Des informations plus détaillées concernant les opérations de décalage sont
fourni au chapitre 4.3.2.
Exemple :
Avant :
R5 = 5
R7 = 8
MOV R7, R5, LSL#2 @ r7 = r5*4 = (r5 << 2)
Après :
R5 = 5
R7 = 20
4.1.2 La syntaxe de la notation

Les descriptions des instructions suivantes utilisent la notation du Tableau 15. Les éléments de la syntaxe, qui
sont souvent utilisé, sont traités plus en détails dans les chapitres suivants.
[ ] Accès indirect, indexation

{ } Elément facultatif
< > Un élément parmi d’autres éléments
| Choix parmi une liste (ou)
Tableau 15 : Les éléments de la syntaxe pour la description formelle des instructions.
Accès indirect, indexation []

L’accès s’effectue à l’élément, qui est indexé entre parenthèses. L’indexation peut être soit l’adresse d’une case
mémoire ou une position de bit. Ainsi [Rn] représente la valeur de la variable, qui est adressée par l’adresse
stockée dans Rn.
Choix parmi une liste |

Cette notation permet de choisir un élément parmi une liste. LDR|LDRB est par exemple une autre formulation
pour LDR{B}.
Un élément parmi une liste <>

La notation <> représente exactement un élément parmi une liste. La liste est en générale soit une collection de
valeur ou un espace d’adressage.
Les éléments facultatifs {}

Les éléments facultatifs dans une expression sont définies entres accolades. La notation LDR{B} est par
exemple une abréviation pour LDR|LDRB.
Les noms de registre

Rd, Rm, Rn, Rs, RdHi & RdLo sont des registres ARM R0-R15.
Ld, Lm, Ln & Ls représentent les registres ARM inférieur R0-R7.
Hd, Hm, Hn & Hs représentent les registres ARM supérieurs R8-R15.

Cd, Cm & Cn sont des registres du coprocesseur dans la zone C0-C15

SP, LR et PC sont des synonymes pour R13, R14 et R15.
Rn[a] représente le bit a de la valeur, qui est stockée dans le registre Rn.
Rn[a:b] représente la suite des bits depuis la position a jusqu’à b du contenu du registres Rn.
RdHi:RdLo représente une valeur 64 bits. RdHi est ainsi le mot de poids le plus fort et RdLo le mot de poids
le plus faible.
Les valeurs constantes

<immedN> représente une valeur entière, qui est représentée avec N bits. Ainsi <immed8> représente une
valeur dans le domaine 0..255.
<immedN>*size représente une suite de nombres, avec des pas successifs size. Ainsi <immed5>*4
représente une valeur parmi 0, 4, 8, …, 124.
<AddressN> est une adresse de case mémoire, représenté avec un déplacement (offset) relatif. L’adresse doit
se situer dans la zone pc-2N <= adresse < pc+2N.
<A-B> représente une valeur entière dans la zone A à B.
<rotated_immed> est une valeur 32 bits, qui est représentée par une valeur 8 bits non signées et qui peut être
déplacé vers la gauche ou vers la droite par pas de deux bits. C'est-à-dire que par exemple <rotated_immed>
est équivalent à <immed8> ROR (<immed4>*2).
Le code d’état du programme

<cond> représente tous les bits du registres d’état du processeur ARM selon le Tableau 16.
Les opérations de décalage

<imm_shift> représente l’argument de décalage, qui est une constante. Le domaine de validité de cette
constante dépend naturellement du type de l’opération de décalage, comme Par exemple : LSR: #<1-31>,
ASR: #<1-32>.
<reg_shift> est l’argument de décalage, qui est représenté par le contenu d’un registre.
<shift> comprend à la fois <imm_shift> et <reg_shift>.
4.1.3 Exécution d’instruction conditionnelle

Presque toutes les instructions peuvent être exécutées de façon conditionnelle (comme p.ex. les sauts de
programme, les instructions arithmétiques et logiques, etc.). Dans la plupart des procédures, Les instructions
arithmétiques et logiques conditionnelles permettent d’éviter les sauts conditionnels. Ce qui permet de réduire le
temps d’exécution du programme. En effet les sauts conditionnels nécessitent une vidange du pipeline des
instructions lors de mauvaise anticipation de leur comportement. Cependant, les instructions arithmétiques et
logiques conditionnelles doivent être introduites par une instruction If-Then-Else (ITE) avec le jeu
d’instructions Thumb2 (voir chapitre 4.6.1).
Les conditions, qui doivent être évaluées pour l’exécution des instructions conditionnelles, sont lues à partir des
bits du registre APSR. Ces derniers sont normalement fixés par l’instruction, qui a été exécutée en dernier par le
processeur (en générale des opérations de comparaison). La condition est notée comme suffixe (ou code de
condition) après l’instruction. Le Tableau 16 contient les différentes conditions.
Les opérations non comparatives, qui sont exécutées par l’unité arithmétique (ALU), peuvent également
influencer les bits d’état. Dans ce cas il faut ajouter un suffixe S au code d’opération. Les opérations
arithmétiques peuvent influencer les bits N, Z, C et V ; les opérations logiques les bits N et Z ; et le décalage à
barillet (barrel-shifter) uniquement le bit C.

Condition Drapeau (flag) Description

EQ Z Egalité
NE !Z Inégalité
CS,HS C Plus grand que ou égalité (non signé)
CC,LO !C Plus petit (non signé)
MI N Minus, négatif
PL !N Positif ou nul
VS V Dépassement de capacité (Overflow)
VC !V Pas de dépassement de capacité
HI C && !Z Plus grand que (non signé)
LS !C && Z Plus petit que ou égalité (non signé)
GE (N == V) Plus grand que ou égalité (signé)
LT (N != V) Plus petit que (signé)
GT !Z et (N == V) Plus grand que (signé)
LE Z ou (N != V) Plus petit que ou égalité (signé)
Tableau 16 : Les conditions (condition code) pour les instructions conditionnelles
Les suffixes LO ou HS peuvent être utilisées au lieu de CC ou CS. Ces derniers, comme les suffixes LS et HI, se
réfèrent à des opérations de comparaison non signée. Par contre LT, GE, LE et GT se réfèrent à des opérations de
comparaison signée. Le suffixe AL (always) doit être mentionné pour des raisons d’intégralité. Ce dernier existe
de façon formelle et représente la condition standard en absence de suffixe. Toutefois l’assembleur gcc ne
l’admet pas comme suffixe en présence d’instructions.
Exemple :
Définition du GGT (a, b), qui peut être défini dans un langage de programmation évoluée à l’aide d’une
division en chaîne de la manière suivante :
while (a != b) {
if (a > b)
a -= b ;
else
b -= a ;
}
Une première implémentation en assembleur ARM avec les registres r1 et r2 pour le stockage respectif de a
et b :
ggt: CMP r1, r2

BEQ endIf
BLT aIsSmaller
SUB r1, r1, r2
B ggt
aIsSmaller:
SUB r2, r2, r1
B ggt
endIf:
Cette solution est basée sur des sauts de programme. A chaque saut il faut vider le pipeline des instructions
lorsque le comportement de ce dernier n’a pas être anticipé. Ce qui ralenti fortement le temps d’exécution du
programme. Les instructions conditionnelles permettent de réduire ce temps d’exécution. De plus le programme
devient plus court.
ggt: CMP r1, r2

ITE GT
SUBGT r1, r1, r2
SUBLT r2, r2, r1
BNE ggt
endIf:
Le registre de compteur de programme peut être utilisé comme registre de destination avec toutes les opérations
ALU. Les processeurs ARM soutiennent les formats petit-boutistes et gros-boutistes (little and big endian). Le

standard est cependant le format petit-boutiste.
4.2 La vue d’ensemble du jeu d’instructions

Les opérations du jeu d’instructions Thumb2 peuvent être réparties dans les groupes suivants :
 Les transferts de données
 Les instructions arithmétiques et logiques
- L’arithmétique des entiers
- Les instructions logiques
- Les instructions de décalage et de rotation
- Les manipulations de bit
 Les sauts de programme
- Les sauts non conditionnels
- Les sauts conditionnels
 Les instructions de control du system
Les chapitres suivants traitent ces groupes d’instructions.
4.3 Les transferts de données

De par son architecture RISC, le processeur Cortex-M4 ne connaît que les opérations de transfert de données
entres registres (MOV), depuis la mémoire périphérique aux registres (LDR) et depuis les registres à la mémoire
périphérique (STR). Les transferts de données entres mémoires périphériques ne sont pas possibles. Ils peuvent
être réalisés de façon byte (8 bits), demi-mot (16 bits) et mot (32 bits). Cependant, l’accès demi-mot ou mot n’est
possible qu’avec un adressage demi-mot ou mot, c'est-à-dire divisible par 2 ou 4 (.align 2 ou .align 4).
Instruction Opérande Opération Description

SWP Reg1,Reg2,Reg3 Reg2 -> [Reg3], Echange le contenu du registre avec la
Reg1 <- [Reg3] mémoire
MOV Reg,Op2 Reg := Op2 Copier le contenu d’un registre ou une
valeur constante dans un registre
MVN Reg,Op2 Reg := ~OP2 Copier le complément à un du contenu
d’un registre ou d’une valeur constante
dans un registre
LDR Reg, Address Reg := [address] Charger le contenu de la mémoire dans
un registre
STR Reg, Address [address] := Reg Stocker le contenu d’un registre dans la
mémoire
MSR Reg PSR := Reg Copier le contenu du registre dans le
registre d’état du programme PSR
(Status/Flags)
MRS Reg Reg := PSR Copier le contenu du registre PSR
(Status/Flags) dans un registre
MCR p#, op, cReg, cReg := Reg1 {op Reg2} Exécuter l’opération op à l’aide du
Reg1, Reg2 coprocesseur p# et stocker le résultat
dans le registre du coprocesseur.
MRC p#, op, Reg1, Reg := cReg1 {op cReg2} Exécuter l’opération op à l’aide du
Reg2 coprocesseur p# et stocker le résultat
dans le registre Reg2.
LDC p#, cReg, cReg := [Address] Charger le registre du coprocesseur
Address avec le contenu de la mémoire
STC p#, cReg, [Address] := cReg Charger le registre du coprocesseur
Address avec le contenu de la mémoire
LDM Rbase,{Rlist} [Rbase] -> {Rlist} Charger plusieurs registres avec le
contenu de la mémoire (pile pop)
STM Rbase,{Rlist} {Rlist} -> [Rbase] Stocker le contenu de plusieurs dans la
mémoire (pile push)
Tableau 17 : Les instructions de transfert de données, entre registres et
depuis les registres à la mémoire périphérique.

4.3.1 Les instructions de transfert de données entre registres MOV

et MVN
Ces instructions permettent de transférer les données entre registres mais, également, de charger les registres
avec des valeurs constantes.
La syntaxe générale est la suivante :
<MOV|MVN>{S}{<cond>} Rd, N
Le code d’opération MOV charge une valeur alors que MVN en charge le complément à un. Un suffise de
condition <cond> du Tableau 16 peut être ajouté à ce dernier afin de pouvoir l’exécuter de façon
conditionnelle. Quant au suffixe S, il permet à l’opération de changer les bits d’état du processeur. L’opérande
Rd représente toujours le registre de destination, alors que l’opérande N peut représenter soit le contenu d’un
registre (éventuellement décalé) ou une valeur constante.
Exemple :
MOV r0, r1 @ r0 := r1
MOVS r0, #10 @ r0 := 10, fixe les bit d’état du programme
MVN r1, r0 @ r1 := ~r0
MOV pc, lr @ retour depuis la sous-routine
4.3.2 Le décalage à barilier (Barrel Shifter)

Les opérandes, qui sont contenus dans des registres (Rm), peuvent être prés décalés à l’aide du décalage à
barilier. En fonction de l’instruction, la valeur de cet opérande peut ainsi être décalée de 0 à 32 bits soi vers la
gauche ou vers la droite. L’opération de décalage est toujours réalisée en un seul cycle d’horloge,
indépendamment du nombre de bits du décalage. La valeur d’origine dans le registre Rm n’est pas changée.
L’ALU traite effectivement la valeur contenue dans le registre Rn et celle fournie par le décalage à barilier N.
Rn Rm
Barrel-Shifter
Zwischenresultat N
ALU
Rd
Figure 69 : ALU avec le décalage à barilier
Certaines instructions de traitement de données comme MUL, CLZ ou QADD ne sont pas en mesure d’utiliser le
décalage à barilier. Dans ces cas, la valeur du registre Rm ne peut être utilisée que de façon non décalée.
Exemple :
Avant l’opération arithmétique, le contenu du registre Rm est décalé de deux bits vers la droite (LSR). Ce qui
correspond à une division par 4 de la valeur du registre. L’opération de décalage est équivalent à l’opérateur >>
du langage de programmation C.
Avant :
r0 = 0x11
r1 = 0x22
MOV r0, r1, LSR #2 @ r0 = r1 / 4

Après :
r0 = 0x8
r1 = 0x22
Le décalage à barilier connaît 5 sortes d’opération de décalage. Ces derniers sont fournis dans le Tableau 18 :
Instruction Effet Opération Résultat Domaine de

décalage
LSL Décalage logique vers la gauche x LSL y x << y #0-31 ou Rs
LSR Décalage logique vers la droite x LSR y (non signé) x >> y #1-31 ou Rs
ASR Décalage arithmétique vers la x ASR y (signé) x >> y #1-31 ou Rs
droite
ROR Rotation vers la droite x ROR y ((non signé) x>>y) | (x << (32-y)) #1-31 ou Rs
RRX Extension de la rotation vers la x RRX (cflag << 31)|((non signé) >> 1) 1 (fixe)
droite
Tableau 18 : Les opérations du décalage à barilier,
où x représente la valeur à décaler et y le nombre de bit du décalage.
La syntaxe du décalage permet de définir le nombre de bit à décaler soit sous forme direct #<immed5> ou à
l’aide d’un registre Rs, qui contient le nombre de bit du décalage. Le Tableau 19 illustre pratiquement toutes les
formulations possibles.
Opération de décalage pour N Syntaxe

Décalage logique vers la gauche en fonction d’une valeur constante 32 bits Rm, LSL #<immed5>
Décalage logique vers la gauche en fonction du registre Rs Rm, LSL Rs
Décalage logique vers la droite en fonction d’une valeur constante 32 bits Rm, LSR #<immed5>
Décalage logique vers la droite en fonction du registre Rs Rm, LSR Rs
Décalage arithmétique vers la droite en fonction d’une valeur constante 32 bits Rm, ASR #<immed5>
Décalage arithmétique vers la droite en fonction registre Rs Rm, ASR Rs
Rotation vers la droite en fonction d’une valeur constante 32 bits Rm, ROR #<immed5>
Rotation vers la droite en fonction du registre Rs Rm, ROR Rs
Rotation vers la droite étendue (33-Bit Rotation) Rm, RRX
Tableau 19 : La syntaxe des différentes opérations du décalage à barilier.
Exemple :
L’opération MOVS copie le contenu du registre r1, préalablement décalé de un bit vers la gauche, dans le
registre r0. Du fait que l’instruction contient le suffixe S, elle est en mesure de changer le contenu du registre
d’état courant du programme. Le bit 31 du registre r1 est ainsi copié dans le bit de carry.
Avant :
PSR = nzcvq (Majuscule: mise à un, minuscule: mise à zéro)
r0 = 0x00000000
r1 = 0x80008001
MOVS r0, r1, LSL #1
Après :
PSR = nzCvq
r0 = 0x00010002
r1 = 0x80008001

n z c v 31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1
cpsr r1
r0
0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0
n z c v 31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
Werden gesetzt bei einer

Instruktion mit S-Suffix
Figure 70 : L’instruction MOVS avec une opération de décalage LSR #1. Le bit 31 est copié dans le bit de carry
du registre d’état courant du processeur, car l’instruction MOV a été définie avec le suffixe S.
4.3.3 Les instructions de chargement de données LDR et STR

Les instructions de chargement de données permettent de transférer les données depuis la mémoire aux registres,
ou inversement. Le chargement d’une valeur constante dans un registre, qui ne peut pas être réalisé directement
avec les instructions MOV ou MVN, est également réalisé avec l’instruction LDR. Toutes les instructions de
chargement, mis à part LDRD et STRD, peuvent être exécutées pour des types de données mot, demi-mot ou
byte. Le Tableau 20 fournit une vue d’aperçu de ces instructions.
Instruction Description Effet

LDR Charger un mot dans un registre Rd := mem32[Adresse]
STR Stocker un mot à partir d’un registre Mem32[Adresse] := Rd
LDRB Charger un byte dans un registre Rd := mem8[Adresse]
STRB Stocker un byte à partir d’un registre mem8[Adresse]:= Rd
LDRH Charger un demi-mot dans un registre Rd := mem16[Adresse]
STRH Stocker un demi-mot à partir d’un registre mem16[Adresse] := Rd
LDRSB Charger un byte signé dans un registre Rd := (signExtend) mem8[Adresse]
LDRSH Charger un demi-mot signé dans un registre Rd := (signExtend)
mem16[Adresse]
STRD Stocker deux mots à partir de registres (DSP) Mem32[Adresse] := Rd
Mem32[Adresse+4] := R(d+1)
LDRD Stocker deux mots dans des registres (DSP) Rd=Mem32[Adresse]
R(d+1)=Mem32[Adresse+4]
Tableau 20 : Les opérations de chargement. Le bit de signe est dupliqué avec les transferts de données signées.
La syntaxe des instructions LDR et STR est la suivante :
<LDR|STR>{B|H|D}{<cond>} Rd, <Address>

LDR{SB|SH}{<cond>} Rd, <Address>
L’adresse de la case mémoire peut être définie de plusieurs manières. Dans les cas les plus simples, cette
dernière peut être une constante ou un registre. Les modes d’adressage sont traités plus en détails dans le chapitre
suivant.
Les instructions LDRD et STRD sont des extensions du jeu d’instruction DSP. Ces dernières permettent
respectivement de charger et de stocker le contenu de deux registres juxtaposés. La condition pour Rd est un
registre avec un numéro pair. Par exemple, l’instruction STRD avec Rd = r2 stockent le contenu des registres
r3 et r4 dans la mémoire.
Exemple :
Les instructions LDR et STR permettent respectivement de charger et de stocker les données dans la mémoire. La
condition pour l’adressage de la case mémoire est son alignement avec les types de données à transférer. C'est-à-
dire que cette dernière doit être divisible par 4 pour les accès mot et paires pour les accès demi-mot.

/* Charge le registre r0 avec la valeur contenue par la case mémoire,

qui est adressée par le registre r5. */
LDR r0, [r5]
/* Stocker le contenu du registre r0 dans la case mémoire,

qui est adressée par le registre r5. */
STR r0, [r5]
/* Charge le registre r0 avec la valeur contenue par la case mémoire,

qui est adressée par le symbole myvar
(myvar doit être définie dans le même segment). */
STR r0, myvar
4.3.4 Modes d’adressage pour les instructions de chargement et de

stockage
L’architecture ARM prévoit de nombreux modes d’adressage. L’adresse de la case mémoire à accéder est
toujours composée d’une adresse de base et d’un index (c. à d. un déplacement). La base est contenue dans
n’importe quel registre, mis à part celui du compteur de programme pc.
Selon la formule de lecture ARM, les modes d’adressage sont qualifiés de « méthode d’indexation ». Il existe
fondamentalement trois méthodes d’indexations. Ces dernières peuvent être complétées avec des nombreuses
variantes de calcul du déplacement (offset).
Méthode d’indexation Données Registre contenant Exemple

l’adresse de base
Pré indexation avec retour mem[Basis+Offset] Basis+Offset LDR r0,[r1,#2]!
Pré indexation mem[Basis+Offset] Basis+Offset LDR r0,[r1,#2]
Post indexation mem[Basis+Offset] Basis+Offset LDR r0,[r1],#2
Tableau 21 : Les méthodes d’adressage (d’indexation) pour l’accès à la mémoire. Le déplacement est toujours
une grandeur signée. Par exemple, ce dernier peut être défini comme une valeur ± 12 bits.
Dans la méthode pré indexation, l’adresse de la case mémoire est obtenue par addition du contenu du registre de
base avec le déplacement. Le contenu du registre de base reste constant durant toute l’opération de transfert.
Cependant, si l’on définit une récriture en retour (write back) avec « ! », la nouvelle adresse est copié dans le
registre de base avant le transfert de données.
La méthode post indexation reprend également la nouvelle adresse, mais après le transfert de données.
Les méthodes post et pré indexation avec write back sont surtout utilisées pour les accès aux Tableaux (array).
Quant à la méthode pré indexation, elle est souvent utilisée pour accéder aux structures de données.
Exemple :
L’exemple suivant montre les accès avec les modes d’adressage selon le Tableau 21, avec les valeurs des
registres avant et après l’exécution du transfert de données. Toutes les instructions possèdent la même situation
initiale.
Avant :
r0 = 0x000000000
r1 = 0x000100000
mem32[0x00010000]=0x10101010
mem32[0x00010004]=0x20202020
Pré indexation avec write back
LDR r0, [r1, #4]!

Après :
r0 = 0x20202020
r1 = 0x00010004
Pré indexation :
LDR r0,[r1,#4]
Après :
r0 = 0x20202020
r1 = 0x00010000
Post indexation :
LDR r0,[r1],#4
Après :
r0 = 0x10101010
r1 = 0x00010004
Il existe de nombreuses variantes pour le calcul du déplacement (offset) : des valeurs directes, des contenus de
registre ou des contenus de registre décalés. Tableau 22 fournit une vue d’aperçu des modes d’adressage pour les
accès du type mot ou byte non signés.
Mode d’adressage Syntaxe

Pré indexation avec un offset constant [Rn, #<offset12>]
Pré indexation avec un offset registre [Rn, Rm]
Pré indexation avec un décalage de l’offset registre [Rn, Rm, shift #<shift_value>]
Pré indexation avec write back et un offset constant [Rn, #offset12]!
Pré indexation avec write back et un offset registre [Rn, Rm]!
Pré indexation avec write back et un décalage de l’offset [Rn, Rm, shift #<shift_value>]!
registre
Post indexation avec un offset constant [Rn], #<offset12>
Post indexation avec un offset registre [Rn], Rm
Post indexation avec un décalage de l’offset registre [Rn], Rm, shift #<shift_value>
Tableau 22 : La syntaxe des modes d’adressage pour les accès simple de type mot
Des limitations existent pour les autres instructions. Par exemple, les instructions STRSB, STRSH, STRH et
STRB ne peuvent pas utiliser le décalage à barilier (barrel-shifter). De plus le déplacement est limité à +/- 8 bits
autour de l’adresse de base.
Mode d’adressage Syntaxe

Pré indexation avec un offset constant [Rn, #<offset8>]
Pré indexation avec un offset registre [Rn, Rm]
Pré indexation avec write back et un offset constant [Rn, #<offset8>]!
Pré indexation avec write back et un offset registre [Rn, Rm]!
Post indexation avec un offset constant [Rn], #<offset8>
Post indexation avec un offset registre [Rn], Rm
Tableau 23 : Les méthodes d’adressage autorisées pour les types de données signés et non signés.

Exemple en conclusion :
str r1, [r2, r4]! @ store r1 in [r2+r4] & copy the new address in r2
str r1, [r2], r4 @ store r1 in [r2] & copy the new address in r2
str r1, place @ store r1 pc relative in place
ldr r1, [r2, #16] @ load r1 with [r2+16]. r2 will not change
ldr r1, [r2, r3, LSL#2] @ load r1 with [r2+r3*4] laden
ldreqb r1,[r2,#5] @ conditional load the byte of r1 with [r2+5].

@ the bits D8 up to D31 will be full with zero.
4.3.5 L’instruction SWP

L’instruction SWP permute le contenu d’un registre avec celui d’une case mémoire. Elle représente ainsi une
combinaison des instructions STR et LDR. Elle est exécutée comme une instruction atomique à l’aide du
système de bus, et ne peut ainsi pas être interrompue par une interruption jusqu’à ce que le transfert de données
ne soit terminé.
La syntaxe est la suivante :
SWP{<cond>}{B} Rd, Rm, [Rn]
Instruction Description Déroulement interne

SWP Echange de mot entre le registre et tmp = mem32[Rn]
la mémoire mem32[Rn] = Rm
Rd = tmp
SWPB Echange de byte entre le registre et tmp = mem8[Rn]
la mémoire mem8[Rn] = Rm
Rd=tmp
Tableau 24 : Effet des instructions SWP et SWPB
Exemple :
L’instruction SWP charge la donnée depuis la case mémoire 0x0001A000 dans le registre r0 et copie le
contenu du registre r1 dans la case mémoire 0x0001A000.
Avant :
r0 = 0x555555555
r1 = 0xAAAAAAAAA
r2 = 0x0001A0000
mem32[0x0001A000]=0x10101010
SWP r0, r1, [r2]
Après :
r0 = 0x10101010
r1 = 0xAAAAAAAAA
r2 = 0x0001A0000
mem32[0x0001A000]=0xAAAAAAAA

ARM- Prozessorregister Arbeitsspeicher (RAM)
r0 0x55555555
0x10101010
r1 0xAAAAAAAA
0x19FFC
r2 0x0001A000
0x10101010
0xAAAAAAAA
r3
0x1A004
r4
0x1A008
r5
0x1A00C
r6
0x1A010
r7
0x1A014
r15
4.3.6 Chargement et stockage multiple LDM et STM

Les opérations de chargement et de stockage multiple LDM et STM permettent de transférer le contenu d’un bloc
de registres ou de mémoire avec une seule instruction. Ce type de transfert est plus efficace que celui avec
plusieurs instructions de transfert simples.
L’exécution des instructions LDM et STM nécessite 2+N*t cycles d’horloge ; ou N représente le nombre de
registres à transférer et t le nombre de cycle d’horloge nécessaire pour accéder à la mémoire externe. Ces
instructions sont également atomiques, c'est-à-dire qu’elles ne peuvent pas être interrompues par des
interruptions. L’utilisation des instructions LDM et STM peut par conséquent détériorer le temps de latence du
traitement des interruptions.
La syntaxe des instructions LDM et STM est la suivante :

<LDM|STM><AddressMode>{<cond>} Rn{!}, <RegisterBloc>
Le mode d’adressage définit l’accès mémoire selon le Tableau 25. Il est possible de travailler avec des adresses
croissantes (incrémentation) ou décroissantes (décrémentation). De plus, le calcul de la nouvelle adresse peut
être effectué avant ou après le transfert des données. La nouvelle adresse peut également être écrite dans le
registre Rn, comme la pré-indexation avec l’écriture en retour (write back) !
Mode d’adressage Description Adresse de départ Adresse d’arrivée Rn!

IA Incrémenter après Rn Rn+4*N-4 Rn+4*N
IB Incrémenter avant Rn+4 Rn+4*N Rn+4*N
DA Décrémenter après Rn-4*N+4 Rn Rn-4*N
DB Décrémenter avant Rn-4*N Rn-4 Rn-4*N
Tableau 25 : Les modes d’adressage pour les instructions LDM et STM.
Ces derniers définissent la méthode de calcul de l’adresse de la case mémoire.
Le registre Rn contient l’adresse mémoire, ou les données ont été lues ou déposées dans la mémoire. Si le
registre a été défini avec un opérateur d’écriture en retour (!), la nouvelle adresse sera écrite dans le registre,
comme avec les instructions LDR et STR. Le bloc de registre est défini entre accolades. Ce dernier contient tous
les registres, dont le contenu doit être transféré, soit par énumération avec des virgules ({r0, r3, r6}) ou
sous forme de domaine avec un trait d’union ({r0-r3}). Il n’y a pas de règle concernant la définition par
énumération des registres. Cependant, les registres avec les numéros les plus bas sont transportés en premier.
Exemple :
Les exemples suivants montrent l’effet des quatre modes d’adressage du Tableau 25, pour le stockage des
registres r0, r4 et r1 dans la mémoire à partir de l’adresse 0x00010000.

STMIA r9!,{r0,r1,r4} STMIB r9!,{r0,r1,r4}
r9start r0 0x00010000 r9start 0x00010000

r1 r0
r4 r1
r9end r9end r4
0x00010010 0x00010010
STMDA r9!,{r0,r1,r4} STMDB r9!,{r0,r1,r4}
0x0000FFF0 0x0000FFF0
r9end r9end r0
r0 r1
r1 r4
r9start r4 0x00010000 r9start 0x00010000
Exercice :
Le bloc des registres r0 à r4 doit être stocké dans la mémoire à partir de l’adresse 0x0001A000, dans un
ordre croissant. Le registre r6 doit être utilisé comme pointeur et il doit contenir, à la fin de l’instruction, la
dernière adresse mémoire. C'est-à-dire qu’il doit adresser le contenu du registre r4.
Solution :
Premièrement, il faut utiliser l’opérateur d’écriture en retour (!), afin que r6 contienne la dernière adresse après
l’exécution de l’instruction. Ensuite, il faut choisir le mode incrémenté avant, pour que r6 adresse le dernier
élément. Finalement, il faut soustraire 4 à l’adresse mémoire, afin que le programme écrive le contenu du
premier registre à l’adresse 0x0001A000.
ARM- Prozessorregister Arbeitsspeicher (RAM)
r0
r1
LDR r6,0x0001A000-4 0x00019FFC r6 start
STMIB r6!,{r0-r4} r2
0x0001A000 r0
r3
0x0001A004 r1
r6start 0x0001A000-4 r4
0x0001A008 r2
r0 0x0001A000 r5
0x0001A00C r3
r1 r6 0x0001A000-4
0x0001A010
0x0001A010 r4 r6end
r2 r7
0x0001A014
r3
r6end r4 0x0001A010 r15
4.3.7 Les instructions de la pile LDM et STM

Le processeur ARM ne connaît pas d’instruction pour la pile, contrairement aux autres processeurs. Les accès
pile sont réalisés avec les instructions LDM et STM. La gestion de la pile s’effectue à l’aide du pointeur de pile
SP. Ce dernier est associé de façon conventionnelle au registre R13.
Les architectures ARM permettent de configurer librement le fonctionnement de la pile. Par exemple, la pile
peut croître soit de façon ascendante (vers les adresses les plus hautes) ou de façon descendante (vers les
adresses les plus bas). Le mode d’adressage du pointeur de pile est également configurable. Ce dernier peut
adresser soit le dernier élément stocké, en mode plein (Full), ou la prochaine case libre, en mode vide (Empty).
La pile devrait être configurée soit de façon conventionnelle ou en fonction de codes déjà existants. Le standard
d’appel de procédure ARM-Thumb (ARM-Thumb Procedure Call Standard ≡ ATPCS) recommande d’utiliser la
pile en modes décroissant et plein (Full Descending). Les opérations « push » sont ainsi réalisées avec STMFD et
celles « pop » avec LDMFD (voir Tableau 26).
Le Tableau 26 illustre les différentes opérations push et pop en fonction des modes de configuration introduit ci-
dessus :

Mode Description pop =LDM push =STM

d’adressage
FA Full Ascending LDMFA LDMDA STMFA STMIB
FD Full Descending LDMFD LDMIA STMFD STMDB
EA Empty Ascending LDMEA LDMDB STMEA STMIA
ED Empty Descending LDMED LDMIB STMED STMDA
Tableau 26 : Les modes d’adressage pour les accès pile push et pop,
avec leur réalisation à l’aide des instructions LDM et STM.
Exemple :
Selon ATPCS, les opérations avec la pile doivent être réalisées en mode FD. La pile croît ainsi de façon
descendante et le pointeur de pile adresse son dernier élément.
STMFD sp!,{r1,r2}
Vorher: r1=0x00000005 Nachher: r1=0x00000005
r2=0x00000006 r2=0x00000006
sp=0x00020014 sp=0x0002000C
leer (undefiniert) sp 0x00000005 0x0002000C

leer (undefiniert) 0x00000006
sp 0x00000002 0x00020014 0x00000002
0x00000001 0x00000001
Exemple :
L’opération push avec STMED a pour conséquence, que le pointeur de pile adresse la prochaine case vide de la
pile.
STMED sp!,{r1,r2}
Vorher: r1=0x00000005 Nachher: r1=0x00000005
r2=0x00000006 r2=0x00000006
sp=0x00020014 sp=0x0002000C
leer (undefiniert) sp leer (undefiniert) 0x0002000C

leer (undefiniert) 0x00000005
sp leer (undefiniert) 0x00020014 0x00000006
0x00000002 0x00000002
0x00000001 0x00000001
4.3.8 Les instructions de la pile PUSH et POP

Les processeurs Cortex-M4 possèdent également les instructions PUSH et POP pour réaliser des opérations
d’accès à la pile selon le standard APCS (full descending). Comme leur nom l’indique, PUSH permet d’écrire
dans la pile et POP permet de lire à partir de cette dernière.
La syntaxe des instructions LDM et STM est la suivante :

<PUSH|POP> <RegisterBloc>
L’avantage des instructions PUSH et POP par rapport à leur homologues STM et LDM, c’est qu’avec ces dernières
il suffit de définir uniquement le bloc de registre à transférer entres accolades.
4.3.9 Les instructions d’état MRS et MSR

Les instructions d’état permettent de transférer des données avec les registres spéciaux suivants :
 Les registres d’état APSR, IPSR, EPSR, IEPSR, IAPSR, EAPSR & PSR (voir Figure 71)
 Les registres de pointeurs de pile MSP & PSP
 Les registre de masquage d‘interruption PRIMASK, BASEPRI, BASEPRI_MAX, FAULTMASK
 Le registre de contrôle CONTROL

L’instruction MSR permet d’écrire dans les registres spéciaux. Inversement l’instruction MRS permet de lire à
partir de ces registres.
L’accès aux registres spéciaux avec l’instruction MSR dépend néanmoins du niveau de privilège. En effet, les
programmes non privilégié ne peuvent qu’écrire dans le registre APSR. Par contre les programmes privilégiés
peuvent écrire dans tours les registres spéciaux.
La syntaxe des instructions MRS et MSR et la suivante :

MRS{<cond>} Rd, spec_reg
MSR{<cond>} spec_reg, Rm
Figure 71 : Attribution des bits d’état dans le registre PSR
Exemple :
L’activation respectivement le masquage global des interruptions peut être effectué avec le bit PRIMASK (2.5.3).
Pour cela il faut d’abord écrire la valeur souhaitée de ce bit dans un registre de travail (dans cet exemple le
registre R1). Le contenu de ce registre peut ensuite être transféré dans le registre PRIMASK.
Avant :
PRIMASK = P
@ Enable the interruption

MOV R1, #x0 @ Clear R1
MSR PRIMASK, R1
Après :
PRIMASK = p
Cet exemple part du principe que le programme est exécuté au niveau privilégié.

4.4 Les instructions arithmétiques et logiques

Les instructions arithmétiques et logiques constituent la plus grande partie des opérations de traitement de
données. Comme chez la plupart des processeurs RISC, ces dernières ne peuvent s’exécuter que sur des registres.
Les instructions, qui traitent directement les données de la mémoire, ne sont donc pas possibles. Les opérandes et
le résultat des opérations arithmétiques et logiques possèdent un format unique de 32 bits. Toutefois, certaines
opérations peuvent livrer un résultat de 64 bits qui sera alors stocké dans deux registres.
Les instructions de comparaison et de test sont des opérations arithmétiques spéciales. En effet, ces dernières ne
modifient que les bits de condition du registre PSR en fonction du résultat de l’opération. Les bits de condition
constituent la base de décision pour l’exécution des instructions conditionnelles.
La spécialité des processeurs ARM est que leurs instructions arithmétiques et logiques ne modifient pas ses bits
de condition. Toutefois, cela peut être forcé avec le suffixe « S » qu’il faut ajouter à la fin de l’instruction. Les
opérations étendues, comme par exemple les instructions DSP (QADD, SMLA etc.) qui ne font pas partie du jeu
d’instruction du noyau, ne peuvent pas être complétées avec ce suffixe. Elles ne sont donc pas en mesure de
modifier les bits de condition.
Les instructions du Tableau 27 seront décrites dans les chapitres suivants :
Instruction Description
ADD Adition 32 bits
ADC Adition 32 bits avec report de la retenu
AND Opération logique ET
BIC Effacer un bit (NICHT UND)
CMP Comparaison
CMN Comparaison inverse
EOR Opération logique OU exclusive
MUL Multiplication 32 bits
MLA Multiplication et addition 32 bits
ORR Opération logique OU
QADD Addition 32 bits avec protection contre les dépassements de capacité (DSP)
QDADD Addition 32 bits avec protection contre les dépassements de capacité (DSP)
QDSUB Soustraction 32 bits avec protection contre les dépassements de capacité (DSP)
QSUB Soustraction 32 bits avec protection contre les dépassements de capacité (DSP)
RSB Soustraction 32 bits inversé
RSC Soustraction 32 bits inverser avec report de la retenu
SMLA Multiplication 16 bits / addition 32 bits signées (DSP)
SMLAL Multiplication 16 bits / addition 64 bits signées (DSP)
SMLAW Multiplication 32x16 bits / addition signées (DSP)
SMUL Multiplication 16 bits signée (DSP)
SMULW Multiplication 32x16 bits signée (DSP)
SUB Soustraction 32 bits
UMLULL Multiplication 32 bits non signée
Tableau 27 : Aperçu des instructions arithmétiques et logiques.
Cette famille comprend également celles de comparaison et de test.
4.4.1 L’arithmétique des entiers

Ces instructions comportent les opérations de calcul de base et les comparaisons arithmétiques.

Instruction Opérande Description Opération

ADD Rd, Rn, N Addition 32 bits Rd=(Rn+N)
ADC Rd, Rn, N Addition 32 bits avec report Rd=Rn+N+Carryflag

MUL Rd, Rn, Rs Multiplication 32 bits Rd=Rn*Rs
MLA Rd, Rn, Rs, Multiplication / Addition 32 bits Rd=Rn*Rs+Rm
Rm
SMLA<x><y> Rd, Rm, Rs, Multiplication 32 bits / Addition Rd= Rn+Rm*Rs
Rn 32 bits signées
SMLAL Rd, Rm, Rs, Multiplication 16 bits / Addition Rd= Rn+(Rm.<x>*Rs.<y>)
Rn 32 bits signées
SMLAL<x><y> RdLo, RdHi, Multiplication 32 bits / Addition [RdHi,RdLo]=
Rm, Rs 64 bits signées [RdHi,RdLo]+Rm.<x>*Rs.<y>
SMLAW<y> RdLo, RdHi, Multiplication 32x16 bits / Rd=Rn+(((signed)Rm*Rs.<y>)>>16)
Rm, Rs Addition signées
SMUL<x><y> RdLo, RdHi, Multiplication 16 bits signée Rd= Rm.<x>* Rs.<y>
Rm, Rs
SMULW RdLo, RdHi, Multiplication 32x16 bits signée Rd= (Rm* Rs.<y>)>>16
Rm, Rs
SMULL RdLo, RdHi, Multiplication longue signée [RdHi,RdLo]= Rm*Rs
Rm, Rs
UMLAL RdLo, RdHi, Multiplication longue / addition [RdHi,RdLo]= [RdHi,RdLo]+Rm*Rs
Rm, Rs non signées
UMULL RdLo, RdHi, Multiplication longue non [RdHi,RdLo]= Rm*Rs
Rm, Rs signées
QADD Rd, Rm, Rn Addition 32 bits avec protection Rd=sat32(Rm+Rn)
anti-dépassement de capacité
QDADD Rd, Rm, Rn Addition 32 bits avec protection Rd=sat32(Rm+sat32(2*Rn))
anti-dépassement de capacité
QDSUB Rd, Rm, Rn Soustraction 32 bits avec Rd=sat32(Rm-sat32(2*Rn))
protection anti-dépassement de
capacité
QSUB Rd, Rm, Rn Soustraction 32 bits avec Rd=sat32(Rm-Rn)
protection anti-dépassement de
capacité
SBC Rd, Rn, N Soustraction 32 bits avec report Rd=Rn-N-!(Carryflag)
SUB Rd, Rn, N Soustraction 32 bits Rd=Rn-N
RSB Rd, Rn, N Soustraction 32 bits inverse Rd=N-Rn
RSC Rd, Rn, N Soustraction 32 bits inverse Rd=N1-Rn-!(Carryflag)
avec report
CMP Rn,N Comparaison Bit de condition en fonction de Rn-N
CMN Rn,N Comparaison inverse Bit de condition en fonction de Rn+N
TEQ Rn,N Tester l’égalité Bit de condition en fonction de Rn^N
TST Rn,N Tester un bit Bit de condition en fonction de
Rn&N
Tableau 28 : Instructions arithmétiques sur des entiers et de comparaisons
L’opérande N peut être une valeur direct (constante définie avec #), la valeur d’un registre ou le contenu d’un
registre décalé. Les résultats 64 bits sont toujours déposés dans une paire de registres.
Les suffixes <x> et <y> peuvent être soi B (Bottom) ou T (Top). Ces suffixes permettent de limiter les bits de
l’opérande : B correspond au 16 bits de poids plus faibles [0 - 15] et T au 16 bits de poids plus fort [16-31] de ce
dernier. Ici <x> se réfère au registre Rm et <y> au registre Rs.
Certaines instructions DSP possèdent un préfixe Q qui spécifie un traitement avec de l’arithmétique saturée. Ce
qui signifie que les dépassements de capacité ne sont pas possible durant les opérations arithmétiques. Dans ce
cas, lorsqu’il y a dépassement de capacité, le résultat est la valeur signée maximale ou minimale qui peut être
représentée avec 32 bits.

Du fait que l’opérande N peut prendre plusieurs formes, il est logique de pouvoir réaliser la soustraction
également à l’envers. Les instructions de soustraction à l’envers RSB et RSC sont mise à disposition pour cela.
Les instructions CMP, CMN, TEQ, TST réalisent respectivement les opérations SUB, ADD, EOR et AND. Toutefois
ces dernières ne stockent pas le résultat dans un registre. Les instructions MUL et MLA ont la limitation suivante :
le registre Rd ne peut pas être PC ou Rn.
Seules les opérations de comparaison sont en mesure de modifier les bits de condition du registre APSR. Par
défaut, les opérations arithmétiques ne peuvent pas modifier ces bits. Toutefois, si cela devrait être le cas, il
faudrait ajouter un suffixe « S » à la fin de ces dernières.
Exemple :
L’instruction SUB permet de réaliser une simple soustraction. Le code suivant soustrait la valeur du registre R2
à celle du registre R1 et stocke le résultat dans le registre r0
Avant :
R0 = 0x00000000
R1 = 0x00000005
R2 = 0x00000002
SUB R0, R1, R2
Après :
R0 = 0x00000003
Exemple :
Le jeu d’instruction ARM ne comprend pas les instructions d’inversion. Cela peut être réalisé avec une avec une
soustraction inversée de la manière suivante : –z=0-z.
Avant :
R0 = 0x00000002
RSB 0, r0, #0
Après :
R0 = 0xFFFFFFFE
Exemple :
Une boucle de compteur peut être réalisée facilement avec l’instruction SUBS. Le code suivant décrémente la
valeur du registre R1. Le résultat (qui dans cet exemple est nul) est stocké dans le registre R1. Parallèlement, Le
bit de condition Z du registre d’état APSR est mis à un. Ce qui pourrait être la condition de base pour un saut
conditionnel.
Avant :
APSR = nzcvq
R1 = 0x00000001
SUBS R1, R1
Après :
APSR = nZcvq
R1 = 0x00000000
Exemple :
Les processeurs ARM avec l’extension E possèdent de nombreuses instructions DSP. Cela concerne également
des opérations, qui ne traitent qu’une partie de l’opérande. Le suffixe B permet dans ces cas de spécifier le demi-
mot inférieur (bits 0-15) et le suffixe T le demi-mot supérieur (bits 16-31).

Avant :
R0 = 0x11111111
R1 = 0x22222222
R2 = 0x33334444
R3 = 0x11112222
SMLALBT r0, r1, r2, r3 @ [r0,r1]=[r0,r1]+Lo(r2)*Hi(r3)
Après :
R0 = 0x159E1D95
R1 = 0x22222222
R2 = 0x33334444
R3 = 0x11112222
4.4.2 Les instructions logiques

Ces instructions réalisent les opérations logiques ET, OU, OU exclusif et NON (voir le Tableau 29). Ces
opérations permettent de manipuler les bits (par exemple effacer, mettre à un ou compléter un bit) ou de fixer les
conditions pour les sauts de programme.

AND Rd, Rn, N Opération logique ET entre deux valeurs 32 bits Rd=Rn & N
ORR Rd, Rn, N Opération logique OU entre deux valeurs 32 bits Rd=Rn | N
EOR Rd, Rn, N Opération logique OU exclusive entre deux valeurs Rd=Rn ^ N
32 bits
BIC Rd, Rn, N Effacer le bit (AND NOT) Rd=Rn & ~N
Tableau 29: Les instructions logiques
La syntaxe de l’instruction logique est la suivante :
<Instruction>{S}{<cond>} Rd, Rn, N
L’opérande N peut être une valeur direct (constante avec #), le contenu d’un registre ou le contenu d’un registre
décalé. Contrairement aux nombreux autres processeurs, les opérations logiques n’influencent pas par défaut les
bits de conditions du registre d’état APSR. Si toutefois cela devrait être le cas, il faudrait ajouter un suffixe S à la
fin du code d’opération.
Exemple :
L’instruction BIC permet d’effacer certains bits dans un mot sans influencer les autres. Dans l’exemple suivant,
tous les bits de R2, dont la valeur correspond à « 1 », sont effacés dans le registre R1 et le résultat est stocké
dans R0.
Avant :
R1=0b1111
R2=0b0101
BIC R0, R1, R2
Après :
R0 =0b1010
Exemple :
L’instruction ORR réalise une opération logique OU. Dans l’exemple suivante, cette opération est réalisée entre
les valeurs des registres R1 et R2 et le résultat est stocké dans R0.
Avant :
R0=0x00000000
R1=0x10305070
R2=0x02040608

ORR R0, R1, R2
Après :
R0=0x12345678
4.4.3 Les instructions de décalage et de rotation

Les instructions de décalage et de rotation permettent de réaliser des opérations de déplacement binaire.
Le jeu d’instructions ARM ne soutient pas directement ce type d’opération. Toutefois, ces dernières peuvent être
réalisées indirectement à l’aide de l’instruction MOV (voir chapitre 4.3.1). Par contre le jeu d’instruction Thumb
possède ses propres instructions de décalage et de rotation (voir Tableau 30).
Syntaxe des instructions de décalage et de rotation :
<Instruction>{S}{<cond>} Rd, Rn, N
L’opérande N peut être une valeur direct (constante avec #), le contenu d’un registre ou le contenu d’un registre
décalé.

LSL Rd,Rn,N Décalage logique vers la gauche Rd=Rn<<N
LSR Rd,Rn,N Décalage logique vers la droite Rd=(unsigned)Rn >> N
ASR Rd,Rn,N Décalage arithmétique vers la droite Rd=(signed) Rn >> N
ROR Rd,Rn,N Rotation vers la droite Rd=(unsigned)Rn >> N |
(unsigned)Rn << 32-N
RRX Rd,Rn Rotation étendue vers la droite Rd=(unsigned)Rn >> 1 |
cflag << 31
Tableau 30: Les instructions de rotation et de décalage
Exemple :
Le contenu du registre R0 doit être déplacé de un bit vers la gauche. Ce qui correspond à une multiplication par
2. L’instruction LSL est la solution la plus simple pour ce problème.
Avant :
R0 = 0x00004321
APSR = nzCvq
LSL R0, R0, #1
Après :
r0 = 0x00008642
APSR = nzcvq
n z c v 31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 1 0 0 1 0 0 0 0 1
cpsr r0
r0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 1 0 0 1 0 0 0 0 1 0 0
n z c v 31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
Werden gesetzt bei einer

Instruktion mit S-Suffix

4.5 Les sauts de programme

4.5.1 Généralité
Les sauts de programme peuvent être répartis selon les critères suivants :
a) Les sauts conditionnels ou inconditionnels
b) Les sauts absolus ou relatifs
Un saut de programme conditionnel n’est exécuté que si certaines conditions (bit de condition) sont réalisées. Par
contre, un saut de programme inconditionnel est toujours exécuté.
Les sauts de programme absolus engendrent des sauts à des adresses fixes. Ce type de sauts n’est pas soutenu
directement par les processeurs ARM. Les sauts de programme relatifs engendrent des sauts relatifs, c'est-à-dire
avec un certain déplacement (offset) par rapport à l’adresse courante. Ce déplacement est calculé
automatiquement par l’assembleur. Les processeurs ARM soutiennent uniquement les sauts relatifs.
Saut absolu (par exemple Intel x86, Motorola 68x mais pas ARM!)
Départ du programme à l’adresse 0x0000 : Le même programme est démarré à l’adresse 0x2000 :
0x0000
0x0000 prog. Start
...
...
JMP 0x6000 0x2000 prog. Start
... ...
... ...
JMP 0x6000
...
0x6000 instruktion 1
0x6000 instruktion x
0x8000 instruktion 1
Le programme de gauche, qui est exécuté à partir de l’adresse 0x0000 (Figure de gauche), saute à l’adresse
0x6000 après l’instruction « JMP 0x6000 ». Ce qui est juste. Si ce même programme est exécuté à partir de
l’adresse 0x2000 (Figure de droite), le programme saute toujours à l’adresse 0x6000 après l’instruction
« JMP 0x6000 ». Ce qui est faux.
 Les programmes, qui contiennent des sauts absolus, ne peuvent pas être déplacés dans la mémoire.
Saut de programme relatif
Départ du programme à l’adresse 0x0000 : Le même programme est démarré à l’adresse 0x2000 :
0x0000
0x0000 prog. Start
...
...
B label1 Offset 0x2000 prog. Start
... ...
... ...
B label1 Offset
label1: ...
0x6000
0x6000 instruktion x
0x8000 label1:
Le programme, qui est exécuté à partir de l’adresse 0x0000 (Figure de gauche), exécute un saut relatif (Branch)
d’une certaine distance (offset) à l’étiquette label1. Si ce programme est déplacé dans la mémoire (image de

droite), alors il continuera de fonctionner correctement. Car la distance entre l’instruction « B lable1 » et
l’étiquette lable1 reste constante.
Les programmes, qui contiennent des sauts relatifs, peuvent être déplacés dans la mémoire.
4.5.2 Les sauts de programme inconditionnels

Les sauts de programme inconditionnel sont des instructions, qui permettent d’interrompre le déroulement
séquentiel du programme. Certain de ces instructions sont utilisées pour les appels de sous-routines ou les
changements de mode ARM  Thumb.
La syntaxe du saut de programme inconditionnel est la suivante :
<B|BL> <label>
BX Rm
BLX Rm
Les instructions B et BL nécessitent une étiquette (label). En tant que constante symbolique, cette dernière
représente l'adresse à laquelle le programme doit se poursuivre. L’assembleur calcul la distance (offset) entre
l’adresse de destination et l’adresse de l’instruction en cours d’exécution. Du fait que cet offset doit être stocké
avec 24 bits dans le code d’opération, la destination doit se situer dans une zone de 16 MB par rapport à
l’instruction en cours d’exécution.
Les instructions BX et BLX réalisent le saut selon le contenu du registre Rm. Cela s’avère très utile, lorsque
l’adresse de destination est calculée durant l’exécution du programme ou lue à partir d’un tableau.
Le Tableau 31 contient les quatre instructions destinées aux sauts de programme.
Instruction Distance de Description Effet

saut (offset)
B 32MB Saut de programme général pc = offset (label)
BL 32MB Appel de sous-routine. pc = offset (label)
Saut de programme avec sauvegarde de l’adresse lr = Adresse de l’instruction
de retour dans le registre du relieur lr qui suit BL
BX 4G Identique à B mais possibilité de changement de pc = Rm & 0xfffffffe
jeu d’instructions T = Rm & 1
BLX 4G Identique à BL mais possibilité de changement pc = Rm & 0xfffffffe
de jeu d’instructions T = Rm & 1
lr = Adresse de l’instruction
qui suit BL
Tableau 31 : Les instructions de saut de programme
Les appels de sous routine (sous-programme) doivent être réalisés avec l’instruction BL. En effet, BL stocke
également l’adresse de l’instruction suivante dans le registre de lien LR (R14). Cette dernière peut alors servir
d’adresse de retour depuis la sous-routine.
La valeur de l’offset est stockée avec 24 bits, ce qui le limite à 16MB.
A l’origine, le bit [0] du registre Rm est destiné aux changements de jeu d’instructions : ARM ou Thumb.
Concrètement, si l’on veut effectuer un saut dans une sous routine programmée avec le jeu d’instruction Thumb,
le bit [0] du registre Rm doit être 1. Inversement, si l’on veut effectuer un saut dans une sous routine programmée
avec le jeu d’instructions ARM, ce dernier doit être 0. Par conséquent, les processeurs ARM réalisent le saut
absolu selon l’adresse Rm & 0xFFFFFFFE.
Attention : Du faut que le processeur Cortex-M4 ne fonctionnent qu’avec le jeu d’instruction Thumb2, le bit [0]
du registre Rm doit être toujours être 1.
Exemple :
Les sauts de programme peuvent être réalisés soit en avant ou en arrière. Le calcul de l’offset est effectué
automatiquement par l’assembleur. L’exemple suivant illustre des sauts non conditionnels. Le premier saut

franchit les trois opérations d’addition et arrive directement à la première soustraction. Le deuxième saut exécute
un retour en arrière et réalise ainsi une boucle infinie.
B ahead
ADD R1, R2, #4
ADD R0, R6, #2
ADD R3, R7, #4
ahead:
SUB R1, R2, #4
back:
ADD R1, R2, #4
SUB R1, R2, #4
ADD R4, R6, R7
B back
Exemple :
Les sous-routines sont appelées normalement avec l’instruction BL. Le retour s’effectue avec l’adresse de retour,
qui a été stockée avec BL dans le registre de lien R14 ou LR. L’exemple suivant illustre le principe des appels de
sous-routines et le retour à partir de ces dernières.
...
BL subroutine
ADD r0, r1, r2
...
subroutine:
<Subroutine code >
MOV pc, lr @ Return from subroutine
L’assembleur ARM ne prévoit pas d’instruction spécifique pour le retour à partir des sous-routines. Ce dernier
doit être réalisé soi avec l’instruction « MOV pc, lr », ou avec la lecture de l’adresse de retour depuis la pile.
4.5.3 Les sauts de programmes conditionnels

Le concept d’exécution conditionnelle des instructions d’ARM permet d’exécuter la plupart des instructions de
façon conditionnelle. Cela concerne également les instructions de saut de programme du Tableau 31. Par
conséquent, ces dernières peuvent également être complétées avec des codes de condition.
La syntaxe pour les sauts de programme conditionnels est la suivante :
<B|BL>{<cond>} label
BX{<cond>} Rm
BLX{<cond>} Rm
L’expression <cond> est le code condition sous forme de suffise selon le Tableau 32. Le reste est identique au
chapitre 4.5.2.

Condition Description Drapeau

EQ Equal Z
NE Not Equal !Z
CS,HS Unsigned higher or same C
CC,LO Unsigned lower !C
MI Minus, Negative N
PL Positive or zero !N
VS Overflow V
VC No overflow !V
HI Unsigned higher C && !Z
LS Unsigned lower or same !C && Z
GE Signed greater or equal (N == V)
LT Signed less than (N != V)
GT Signed greater than !Z && (N == V)
LE Less or equal Z || (N != V)
Tableau 32 : Les codes de condition pour l’exécution conditionnelle des instructions.
Exemple :
Une sous-routine doit calculer la faculté d’un nombre entier positif. Ce dernier est transmis à la sous-routine
avec le registre r0. La sous-routine doit ensuite enchaîner les multiplications et retourner le résultat avec le
registre r0.
start:
MOV r0, #5 @ Example 5!
BL FacSuB @ Compute (r0!)
B start
// Subroutine for the faculty computation

// n! = 1 * n * (n-1) * (n-2) * ... * 3 * 2
// Input r0: Argument n
// Output r0: Resultat n!
// Used register: r1
FacSub:
MOVS r1, r0 @ Counter registre
ITT LE @ If n<=0
MOVLE r0, #0 @ then result=0
BLE endFac
MOV r0, #1 @ esle initialize the counter variable
loop:
MUL r0, r1, r0 @ multiplication n*(n-1)*(n-2)*...*3*2
SUB r1, r1, #1
CMP r1, #1
BGT loop
endFac:
MOV pc,lr @ return to the calling subroutine

4.6 Les autres instructions ARM

Ce chapitre contient les instructions spéciales, qui seront décrites de façon plus détaillées dans les chapitres
suivants (p.ex. If-Then-Else, break points et interruption software) ou les instructions qui n’ont pas être assignées
aux sections précédentes.
4.6.1 L’instruction If-Then-Else (IT)

L’instruction IT permet d’exécuter de façon conditionnelle les 4 instructions qui suivent. Toutes les conditions
doivent être formulées soi sous forme direct ou sous forme inversé à partir d’une des conditions du Tableau 32.
Les instructions qui suivent l’instruction IT composent le bloc If-Then-Else.
Syntaxe :
IT{x{y{z}}} <cond>
<cond> spécifie la condition de l’instruction principale et x, y, z spécifient la condition pour les instructions
suivantes selon le Tableau 32.
Remarque très importante concernant les processeurs Cortex-M4 :

Mis à part les instructions de saut conditionnel, toutes les autres instructions conditionnelles (de transfert,
arithmétiques, logiques et de décalage) doivent être définies dans un bloc IT.
Exemple :
ITTE NE ; the next 3 instructions are conditional
ANDNE R0, R0, R1 ; conditional ANDNE don’t change the condition bits
ADDSNE R2, R2, #1 ; conditional ADDSNE change the condition bits
MOVEQ R2, R3 ; conditional MOV
CMP R0, #9 ; convert the hexadecimal digits of R0

; in to ASCII-Character
ITE GT ; the next 2 instructions are conditional
ADDGT R1, R0, #55 ; convert 0xA -> 'A'
ADDLE R1, R0, #48 ; convert 0x0 -> '0'
IT GT ; IT block with only one conditional instruction

ADDGT R1, R1, #1 ; conditional incrementation of R1
dloop:
ITTEE EQ ; the next 4 instructions are conditional
MOVEQ R0, R1 ; conditional MOV
ADDEQ R2, R2, #10 ; conditional ADD
ANDNE R3, R3, #1 ; conditional AND
BNE dloop ; conditional branch,
; which can be defined only at the end of the IT block
IT NE ; the next instruction is conditional

ADD R0, R0, R1 ; syntax error
; IT block does not contain a conditional instruction
4.6.2 Les interruptions software SVC

Les interruptions SVC sont des outils, qui sont mis à disposition pour appeler des routines de services. Dans un
mode non privilégié, ces instructions permettent d’appeler les fonctions du système d’exploitation, qui doivent
être exécuté dans un mode privilégié. Le Tableau 33 traite plus de détail sur le déroulement des interruptions
software. Les exceptions et les interruptions sont traitées plus en détail dans le chapitre 7.

L’instruction SVC engendre un saut de programme à l’adresse 0x0000002C, dans le Tableau des vecteurs
d’interruption (SVCall).
la syntaxe de l’instruction SWI est la suivante :
SVC{<cond>} {<immd8>}
L’opérande de SVC est une valeur entre 0x00 et 0xFF. Ce dernier ne concerne pas le processeur mais le traiteur
d’interruptions software SVCall.
Instruction Opérande Description Effet

SVC SVC_Nummer Interruption Appel le traiteur d’interruptions software SVCall
software
Tableau 33 : Description du déroulement des interruptions software
Exemple :
Le code suivant illustre génère une interruption SVC avec le numéro 0x12, qui est utilisé par le débuggeur.
Avant :
EPSR = ici/it_T_ici/it
PC = 0x00008000
LR = 0x003FFFFF
R0 = 0x12
SWI 0x12
Après :
EPSR = ici/it_T_ici/it
PC = 0x0000002C
LR = r14= 0x0008004
R0 = 0x12
4.6.3 Les points d’arrêt BKPT

L’instruction BKPT génère une exception du type « prefetch data abort », si elle n’est pas traitée par le hardware
du débuggeur. L’opérande <immed16> permet de transmettre une valeur 16 bits à l’instruction BKPT. Le
débuggeur peut traiter cette information et identifier le point d’arrêt avec ce numéro.
La syntaxe de l’instruction BKPT est la suivante :
BKPT {<immed16>}
La valeur nulle est utilisée par défaut, en absence de la spécification <immed16>.
4.6.4 Le comptage des zéros CLZ

Cette instruction compte le nombre de bits zéro, qui précèdent dans une valeur binaire.
La syntaxe de l’instruction CLZ est la suivante :
CLZ{<cond>} Rd, Rm
Le registre Rm ne peut pas être le registre du compteur de programme PC. L’instruction CLZ retourne la valeur
32 lorsque Rm = 0.
Exemple :
Le nombre de bits zéro, qui précèdent dans une valeur binaire, indique de combien une valeur peut être décalée
vers la gauche, sans qu’il n’y ait un dépassement de capacité.

Avant :
r0 = 0x12
r1 = 0x1234
CLZ r0, r1
Après :
r0 = 0x13
r1 = 0x1234
Exemple :
La séquence d’instruction suivante normalise la valeur contenue dans le registre R0. Le premier bit, qui est
différent de zéro, se trouvera ainsi dans D31. L’exemple admet que la valeur à normaliser est différente de 0.
Avant :
R0 = 0x8421
CLZ R1, R0 @ Nombre de déplacement vers la gauche

@ pour la normalisation
MOV R0, R0, LSL R1 @ Normalisation afin que
@ le bit 31 soit mis à un
Après :
R0 = 0x84210000
R1 = 0x10

Informtique 3 Les directives de l’assembleur
5 Les directives de l’assembleur
5.1 Introduction
Les directives de l’assembleur sont des pseudo-instructions, qui permettent de gérer l’assemblage du programme.
Contrairement aux instructions réelles, ces dernières ne sont pas traduites en code machine.
Les directives de l’assembleur dépendent de l’assembleur. En générales les fonctionnalités suivantes sont mises à
disposition :
 Contrôle de l’assembleur
 Contrôle du relieur (Sections et leurs adresses de départ)
 Définition des variables et des constantes
 Formatage de fichiers
5.2 Aperçu
Le Tableau suivant fournit un aperçu des directives les plus importantes de l’assembleur :

Champ des noms Champ des Champ des opérateurs Description

instructions
.arm Définition du jeu d’instructions ARM (32 bit)
.thumb Définition du jeu d’instructions Thumb (16
bit)
.global Nom de symbole Exporter un symbole
.extern Nom de symbole Importer un symbole
.align Alignement, valeur Alignement de l’adressage de la mémoire
.balign
.p2align
Nom de symbole .ascii, .asciz Chaînes de caractères Définition de chaînes de caractères constantes
Nom de symbole .byte Valeurs Définition de constantes de type byte, demi-
.2byte, .hword mot et mot
.4byte, .word
Nom de symbole .space Nombre, valeur Réserver de l’espace mémoire avec
initialisation du bloc en question
.include {chemin} nom de Insérer le contenu d’un fichier
fichier
.equ, .set, = Nom de symbole, valeur Attribuer une valeur à un symbole
.org Adresse Attribuer une adresse absolue
.section Nom de symbole Définition de segments de mémoire
{, drapeau}
.text, .data, Les sections standards
.bss
.end Fin du code source
.if Condition Assemblage conditionnel du programme
.ifdef
.ifndef
.else
.macro Nom de symbole Définition d’une macro
{Paramètre}
.rep Nombre Répétition des blocs de code
.irp Paramètre
.endm Fin d’une macro ou d’une structure de
.endr contrôle
.endif
Tableau 34: Les directives de l’assembleur
5.3 .arm, .thumb

La directive .arm introduit un segment de code, qui est programmé avec le jeu d’instruction ARM. Alors que la
directive .thumb indique un segment de code, programmé avec le jeu d’instruction Thumb. La syntaxe du
mode Thumb est légèrement différente de celle d’ARM. Il ne comprend que les instructions et les registres
Thumb. Les deux directives possèdent respectivement les synonymes suivants : .code32 et .code16.
Exemple :
.arm
... @ 32-Bit ARM Instruction
.thumb
... @ 16-Bit Thumb Instruction

5.4 .global, .extern

Un symbole (sous-routine, variable etc.) peut être rendu public avec les directives .global et .extern. Ces
symboles peuvent ainsi être utilisés (exportés) dans les autres modules.
La directive .extern est acceptée pour des raisons de compatibilité avec les autres langages de programmation
assembleurs. Cependant elle n’a pas d’effet, car l’assembleur considère tous les symboles comme étant externes.
La directive .extern peut toutefois être utilisée pour la documentation de l’interface du module.
Exemple:
main.s lcd.s
.extern InitDisplay .global InitDisplay

... ...
... ...
...
... InitDisplay:
bl InitDisplay ...
...
mov pc,lr
La sous-routine InitDisplay est appelée dans le fichier main.s (le chapitre 6 traite les sous-routines de
façon plus détaillée). La sous-routine InitDisplay est définie et exportée avec la directive .global dans le
fichier lcd.s. L’oubli de la directive .global génère des erreurs de relieur.
Pour des raisons de documentation, la directive .extern permet de montrer que le symbole InitDisplay a
été défini dans un autre module. La directive .extern n’est pas nécessaire pour le relieur (linker).
Contrairement au langage de programmation C, les informations concernant la transmission des paramètres et la

restitution du résultat ne sont pas disponibles en assembleur. En C ces informations sont fournies par la
déclaration de la fonction : extern void func (int). En assembleur c’est le programmeur, qui est
responsable de la programmation correcte du transfert des arguments et de la restitution du résultat des sous
routines.
Exemple :
Un programme minimal en assembleur, qui exécute une boucle infinie, a été défini dans le segment .text. Le
code de démarrage doit effectuer un saut à l’étiquette start, après avoir initialisé le hardware.
.arm
.global start
.text
start: B start
5.5 .align
La directive .align permet de s’aligner sur une adresse 32 bits (modulo 4). Cette directive insère par
conséquent zéro à trois bytes. Les processeurs ARM exigent que les instructions et les données du type mot
(word) du programme soient déposées à des adresses 32 bits.
Exemple :
0000 AA55 .byte 0xaa, 0x55
0002 0000 .align @ Insertion of 2 bytes 0x00
0004 48616C6C .asciz "Hallo"
6F00

La syntaxe suivante est valable pour cette directive :
.align AL {, FB}
L’opérande AL permet de spécifier le déplacement. Ce dernier dépend de la plateforme. Par exemple, la directive
« .align 3 » n’a pas la même signification chez les processeurs ARM et i386. Cette dernière correspond
respectivement à un déplacement de huit et trois bytes. L’opérande FB permet de définir les bytes de
remplissage.
Exemple :
Le code suivant illustre les effets des directives .align. Dans cet exemple, la directive .align 3 permet de
s’aligner sur la prochaine adresse, qui est un modulo de 23 = 8.
0000 AA .byte 0xaa

0001 FFFFFFFF .align 3, 0xFF @ modulo 8 alignment & 0xFF fill
FFFFFF
0008 48616C6C .asciz "Hello"
6F00
000e 0000
Du fait que la directive .align dépend des plateformes, deux nouvelles directives d’alignement ont été
spécifiées par le standard GNU : balign et .p2align. Ces dernières ne dépendent plus des plateformes.
Exemple :
La directive .align 8 engendre un alignement à la prochaine adresse modulo 28 = 256:
.data
0000 55 .byte 0x55
0001 11111111 .align 8, 0x11
11111111
11111111
11111111
11111111
0100 FF .byte 0xff
0101 00000000
5.5.1 .balign
La directive .balign (byte align) fonctionne comme .align, mis à part que le paramètre d’alignement AL
est toujours défini en byte. Ce dernier décrit la valeur modulo, sur laquelle l’alignement doit avoir lieu. La
directive .balign 8 engendre, indépendamment de la plateforme, un alignement sur une adresse modulo 8
bytes.
Les directives .balignw et .balignl sont des cas particuliers de .balign. En effet, ces derniers
considèrent le byte de remplissage comme un demi-mot (2 bytes) ou un mot (4 bytes).
Exemple :
La directive .balign peut être utilisée de façon universelle. Le paramètre d’alignement doit toujours être
défini en byte et doit être une puissance de 2. Les autres valeurs engendrent un message d’erreur.

.data
0000 FF .byte 0xFF
.balign
0001 FF .byte 0xFF
.balign 2
0002 FF .byte 0xFF
0003 00 .balign 4
0004 FF .byte 0xFF
0005 000000 .balign 8
0008 FF .byte 0xFF
Exemple :
La directive « .balignw 4,0x1234 » exécute un alignement à une adresse modulo 4. Si un déplacement de
2 bytes a lieu, il sera rempli avec la valeur 0x1234. La déposition des bytes dans la mémoire dépend du mode
boutiste du processeur. Les déplacements de un ou trois bytes engendrent des messages d’erreurs.
.data
0000 FFFFFFFF b1: .byte 0xFF, 0xFF, 0xFF, 0xFF
0004 .balignw 4, 0x1234
0004 FFFF b2: .byte 0xFF, 0xFF
0006 3412 .balignw 4, 0x1234
5.5.2 .p2align
La directive .p2align (power of 2 align) fonctionne comme .align, mis à part que le paramètre de
déplacement AL y est défini sous la forme exponentielle. Cette dernière fournit la valeur modulo, sur laquelle il
faut s’aligner. La directive « .p2align 3 » engendre, indépendamment de la plateforme, un alignement sur
une adresse modulo 8 bytes.
Les cas particulier sont ici .p2alignw et .p2alignl. Ces derniers considèrent les bytes de remplissage
respectivement comme des demi-mots et des mots.
Exemple :
La directive « .p2align 3 » se réfère toujours sur des adresses, qui sont des multiples de 8. Les espaces de
déplacement sont remplis avec des valeurs nulles.
.data
0000 10 b1: .byte 0x10
0001 00000000 .p2align 3
00000
0008 33 b2: .byte 0x33
Exemple :
Les directives « .p2alignw 2, 0x1234 » génèrent des déplacements sur des adresses, qui sont des
multiples de 4. Les espaces de déplacement du type mot sont remplis avec la valeur 0x1234. La suite des bytes
dépend du mode boutiste du processeur. Les déplacements de un ou trois bytes engendrent des messages
d’erreurs.
.data
0000 FF b1: .byte 0xFF
0001 565656 .p2align 2, 0x56
0004 FFFF b2: .byte 0xFF, 0xFF
0006 3412 .p2alignw 2, 0x1234

5.6 .ascii, .asciz

Les directives .ascii et .asciz permettent d’insérer des chaînes de caractères constantes dans le code.
Plusieurs chaînes de caractères peuvent être définies avec une seule directive. Ces dernières doivent toutefois
être séparées par des virgules. Les valeurs ASCII des différents caractères sont directement déposées dans la
mémoire. La directive .asciz termine automatiquement la chaîne de caractère avec le byte de fin de chaîne
(byte nul).
La syntaxe de .ascii et .asciz est la suivante :

{Label :} <.ascii|.asciz> {,<string>} ...
Exemple :
0000 48616C6C .ascii "Hello"
6F
0005 57656C74 .asciz "World!"
2100
5.7 .byte
La directive .byte permet d’insérer des constantes et des variables du type byte dans le code. Plusieurs valeurs
séparées par des virgules peuvent être définies. Ces dernières sont déposées dans le même ordre dans la
mémoire.
La syntaxe de .byte est la suivante :
{label:} .byte <byte1> {,<byte2>} . . .
L’étiquette (label) représente le nom de la constante. Cette dernière est utilisée comme adresse symbolique afin
de pouvoir accéder à la constante. Les valeurs négatives sont stockées en complément à deux. Les valeurs hexa
décimales commencent avec 0x ou 0X, les valeurs octales avec un 0 et les valeurs binaires avec 0b ou 0B. Les
valeurs décimales ne commencent avec un chiffre différent de zéro.
Exemple :
0000 416225 .byte 'A', 'b', 37
0003 20D0 .byte 0x20, -0x30
0005 F608 .byte -10, 010
0007 0A .byte 0B1010
5.7.1 .2byte, .hword

Les directives .2byte et .hword permettent d’insérer des constantes et des variables du type demi-mot (16
bits) dans le code. Ces directives fonctionnent de la même manière que .byte.
La syntaxe de .2byte et .hword est la suivante :
{label:} <.2byte|.hword> <short1> {, <short2>} ...
Exemple :
Les directives .2byte et .hword sont des synonymes. Elles déposent les constantes à 16 bits en respectant
l’ordre de leurs énumérations.

.data
0000 1100 h1: .2byte 0x11
0002 33224400 h2: .2byte 0x2233, 0x44
0006 1100 h3: .hword 0x11
0008 33224400 h4: .hword 0x2233, 0x44
5.7.2 .word, .4byte

Les directives .word et .4byte permettent d’insérer des constantes et des variables du type mot (32 bits). Ces
directives fonctionnent de la même manière que .byte et .2byte.
La syntaxe de .word et .4byte est la suivante :
{label:} <.4byte|.word> <word1> {, <word2>} ...
Exemple :
Les directives .4byte et .word sont des synonymes. Elles déposent les constantes à 32 bits en respectant
l’ordre de leurs énumérations.
.data
0000 11000000 w1: .4byte 0x11
0004 55443322 w2: .4byte 0x22334455, 0x66
66000000
000c 11000000 w3: .word 0x11
0010 55443322 w4: .word 0x22334455, 0x66
66000000
5.8 .space
La directive .space réserve de l’espace mémoire pour un bloc, contenant un certain nombre de bytes. Ce
dernier est normalement utilisé pour le stockage de données.
La syntaxe de .space est la suivante :
{label:} .space <AB> {, <FB>} ...
Le paramètre AB spécifie le nombre de bytes, qui doivent être réservés pour le bloc. Le paramètre en option FB
défini le byte de remplissage, qui sera utilisé pour tout le bloc.
Exemple :
Les blocs de données sont des bytes, qui sont stockés successivement dans la mémoire. Ces derniers peuvent
également être initialisés. Dans les applications embarquées, l’initialisation de cette zone de mémoire est la tâche
du chargeur de démarrage (boot loader).

.data
00000 00000000 .space 0x10
00000000
00000000
00000000
00010 AAAAAAAA .space 0x10000, 0xAA
AAAAAAAA
AAAAAAAA
AAAAAAAA
AAAAAAAA
10010 00000000 .space 0x1234
00000000
00000000
00000000
00000000
5.9 .include
La directive .include copie du code le contenu du fichier à inclure dans le code source. Cette opération est
effectuée durant le processus d’assemblage du programme. Le fichier à inclure doit se trouver dans le répertoire
courant du projet. C'est-à-dire celui, qui contient les fichiers objets. L’option –I de la ligne de commande permet
de spécifier le chemin d’accès aux fichiers à inclure.
La syntaxe de .include est la suivante :

.include "NomFichier"
Exemple :
.include "pxa270.s"
La ligne .include "pxa270.s" sera remplacée par le contenu du fichier « pxa270 ».
5.10 .equ, .set, =

Les directives .equ, .set et = attribuent une valeur à un symbole. Ces directives sont des synonymes et
fonctionnent toutes de la même manière.
Exemple :
1 .text
2 .equ newline, 0xa
3 .set bitmask, 0b10010111
4 TAB = 011
5
6 0000 0A00A0E3 MOV R0, #newline
7 0004 9710A0E3 MOV R1, #bitmask
8 0008 011000E0 AND R1, R0, R1
9 000c 0930A0E3 MOV R3, #TAB
10
11 .equ newline, 100 /* Redefinion of newlin */
12
13 0010 6400A0E3 MOV R0, #newline

Les symboles newline, bitmask et TAB sont dotés de valeurs numériques. La programmation peut être
effectuée avec ces symboles au lieu de leurs valeurs numériques. Cette définition centrale augment la lisibilité du
code et facilite son entretient. La définition directe de valeurs numérique dans le code devrait constituer une
exception.
5.11 .org
La directive .org défini une adresse absolue, à partir de laquelle les instructions (ou les données) du programme
doivent être déposées dans la mémoire. La définition des segments avec .org constitue une exception, avec les
processeurs ARM. Cela provient du fait que les sauts de programme y sont toujours réalisés de façon relative.
Exemple :
.org 0xa0000800
mysub: ...
MOV PC, LR
Dans l’exemple de ci-dessus l’adresse de départ de la sous-routine « mysub » est fixée à 0xa0000800. En
règle générale, l’utilisation de la directive .section est beaucoup plus élégante.
5.12 .section
L’espace mémoire des instructions et des données du programme peut être partagé en plusieurs blocs (segments
ou sections). On distingue fondamentalement le segment du code et celui des données. Le segment du code
(.text) contient les instructions du programme, qui sont stockées en générale dans une ROM. Le segment des
données est composé de variables, de la pile (stack) et d’autres types de grandeurs. On distingue ici l’espace
mémoire à initialiser (.data) et celui à ne pas initialiser (.bss). Le gestionnaire d’amorçage (boot loader) est
responsable de l’initialisation de l’espace .data. Dans les programmes C, ce gestionnaire est appelé par le code
de démarrage du module crt0.s.
Plusieurs segments peuvent être regroupés dans une classe. Les classes les plus importantes sont les suivantes :
.text, .data et .bss. Dans ces classes il est possible de définir des sous classes (segments).
Des nouveaux segments ne doivent en générales pas être définis dans des petits programmes. En générale les
classes prédéfinies, .text, .data et .bss, sont suffisent pour ces derniers. La définition des nouveaux
segments est en revanche nécessaire avec les programmes plus complexes, qui utilisent des modules étrangers.
La directive .section permet de définir des nouveaux segments, ou de modifier ceux qui existent déjà. Toutes
les instructions, qui suivent la directive .section, sont affectées à ce dernier. Contrairement à .org,
l’attribution de l’adresse de départ au segment n’est pas absolue. Cette dernière est réalisée par le processus de
reliage (linker).
Dans l’environnement de développement CARME, l’attribution des adresses absolues aux segments .section
s’effectue avec le script de reliage « ldscript_ram ».
La syntaxe de .section est la suivante :
.section <NomSection> {,"flags"}
Le symbole <NomSection> permet de définir un nouveau segment. Le drapeau "flag" permet de spécifier
les droits d’accès sur le segment. Le Tableau 35 contient les différents drapeaux et leur signification. Les droits
d’accès des classes de bases restent valables en absence de spécification.

Flag Signification
A Segment pour l’allocation de mémoire
W Segment en écriture
X Segment contenant du code exécutable
Tableau 35 : Droit d’accès des segments
Nom de segment (Section) Segment de base Contenu

.text .text Code du programme
.data .data Variables initialisées
.bss .bss Variables non initialisées
.startup .text Code de démarrage
.rodata, .rodata* .text Données en lecture (strings, constants)
.glue_7, .glue_7t .text (ev. .data) Code d’interface ARM - Thumb
Tableau 36 : Nom de segment prédéfini
Les changements de segment, qui ne sont pas en rapport avec les segments de base, doivent être définis avec la
directive .section. Cette dernière peut être omise avec les classes de base :
.text
.data
.bss
.section .subroutines, "x"
.section .text @ Synonyme to .text
.section .startup
.section MySection, "w"
Exemple :
Lorsque des nouvelles sections sont nécessaires, il faut les définir dans le module assembleur. Dans l’exemple
suivant, deux sous-routines sont définies dans le segment « subroutines » :
.text
start:
BL mysub1
BL mysub2
B start
.section .subroutines
mysub1:
MOV pc,lr
.data
b1: .byte 0x22,0x33
msg: .asciz ″Hello″
.section .subroutines
mysub2:
MOV pc,lr
L’affectation du segment subroutines aux classes de base (.text, .data ou .bss) est spécifiée dans le
script du relieur « stm32f4_flash.map ». Ce dernier devrait être affecté logiquement à la classe de base
.text.

Le nouveau segment subroutines doit être ajouté aux sections qui existent déjà dans le manuscrit du relieur
(voir Figure 72). Ce qui permet également de spécifier l’ordre avec lequel les sections doivent être placées dans
la mémoire. Il va sans dire que, les modifications de de manuscrit ne devrait être réalisées qu’en connaissance de
cause et en prenant toutes les précautions nécessaires. Des erreurs à ce niveau se traduisent souvent par des
craches du système.
/* Entry Point */
ENTRY(Reset_Handler)
/* Highest address of the user mode stack */

_estack = 0x20020000; /* end of 128K RAM */
/* Generate a link error if heap and stack don't fit into RAM */
_Min_Heap_Size = 0x1000; /* required amount of heap */
_Min_Stack_Size = 0x1000; /* required amount of stack */
/* Specify the memory areas */

MEMORY
{
FLASH(rx) : ORIGIN = 0x08000000, LENGTH = 1024K
RAM(xrw) : ORIGIN = 0x20000000, LENGTH = 128K
MEMORY_B1(rx) : ORIGIN = 0x60000000, LENGTH = 0K
CCMRAM(rw) : ORIGIN = 0x10000000, LENGTH = 64K
}
/* Define output sections */

SECTIONS
{
/* The startup code goes first into FLASH */
.isr_vector :
{
. = ALIGN(4);
KEEP(*(.isr_vector)) /* Startup code */
. = ALIGN(4);
} >FLASH
/* The program code and other data goes into FLASH */

.text :
{
. = ALIGN(4);
*(.text) /* .text sections (code) */
*(.text*) /* .text* sections (code) */
*(.subroutines) /* .subroutines sections (code) */
*(.rodata) /* .rodata sections (constants, strings, etc.) */
*(.rodata*) /* .rodata* sections (constants, strings, etc.) */
*(.glue_7) /* glue arm to thumb code */
*(.glue_7t) /* glue thumb to arm code */
*(.eh_frame)
KEEP(*(.init))
KEEP(*(.fini))
. = ALIGN(4);
_etext = .; /* define a global symbols at end of code */
} >FLASH
Figure 72 : Insertion de la nouvelle section dans le manuscrit pour le relieur (linkscript)
Les adresses absolues peuvent être lues dans le plan du relieur (linkmap):
Memory Configuration
Name Origin Length Attributes

FLASH 0x08000000 0x00100000 xr
RAM 0x20000000 0x00020000 xrw
MEMORY_B1 0x60000000 0x00000000 xr
CCMRAM 0x10000000 0x00010000 rw
*default* 0x00000000 0xffffffff
Linker script and memory map

0x00001000 malloc_getpagesize_P = 0x1000
0x20020000 _estack = 0x20020000

0x00001000 _Min_Heap_Size = 0x1000
0x00001000 _Min_Stack_Size = 0x1000
.isr_vector 0x08000000 0x188

0x08000000 . = ALIGN (0x4)
*(.isr_vector)
.isr_vector 0x08000000 0x188 src\startup.o
0x08000000 g_pfnVectors
0x08000188 . = ALIGN (0x4)
.text 0x08000188 0xcc

0x08000188 . = ALIGN (0x4)
*(.text)
.text 0x08000188 0x54 c:/program files (x86)/atollic/truestudio for
arm pro
5.1.1/armtools/bin/../lib/gcc/arm-
atollic-eabi/4.8.3/armv7e-
m/softfp/crtbegin.o
.text 0x080001dc 0xc src\main.o
0x080001dc start
*(.text*)
.text.Reset_Handler
0x080001e8 0x4c src\startup.o
0x080001e8 Reset_Handler
.text.Default_Handler
0x08000234 0x4 src\startup.o
0x08000234 RTC_Alarm_IRQHandler
0x08000234 HASH_RNG_IRQHandler
0x08000234 EXTI2_IRQHandler
0x08000234 TIM8_CC_IRQHandler
0x08000234 DebugMon_Handler
0x08000234 TIM1_CC_IRQHandler
0x08000234 DMA2_Stream5_IRQHandler
0x08000234 HardFault_Handler
0x08000234 SysTick_Handler
0x08000234 PVD_IRQHandler
0x08000234 SDIO_IRQHandler
0x08000234 TAMP_STAMP_IRQHandler
0x08000234 PendSV_Handler
0x08000234 NMI_Handler
0x08000234 CAN2_RX1_IRQHandler
0x08000234 TIM8_TRG_COM_TIM14_IRQHandler
0x08000234 TIM1_UP_TIM10_IRQHandler
0x08000234 TIM8_UP_TIM13_IRQHandler
0x08000234 I2C3_ER_IRQHandler
0x08000234 I2C2_EV_IRQHandler
0x08000234 FPU_IRQHandler
0x08000234 OTG_HS_WKUP_IRQHandler
0x08000234 UsageFault_Handler
0x08000234 CAN2_SCE_IRQHandler
0x08000234 SPI1_IRQHandler
0x08000234 TIM6_DAC_IRQHandler
0x08000234 TIM1_BRK_TIM9_IRQHandler
0x08000234 DCMI_IRQHandler
0x08000234 USART6_IRQHandler
0x08000234 USART3_IRQHandler
0x08000234 CRYP_IRQHandler
0x08000234 UART5_IRQHandler

0x08000234 vApplicationMallocFailedHook
0x08000234 TIM4_IRQHandler
0x08000234 I2C1_EV_IRQHandler
0x08000234 UART4_IRQHandler
0x08000234 TIM3_IRQHandler
0x08000234 RCC_IRQHandler
0x08000234 TIM8_BRK_TIM12_IRQHandler
…
0x08000234 OTG_FS_IRQHandler
0x08000234 SPI3_IRQHandler
0x08000234 I2C1_ER_IRQHandler
*(.subroutines)
.subroutines 0x08000238 0x4 src\main.o
*(.rodata)
*(.rodata*)
*(.glue_7)
Figure 73 : Extrait du plan de reliage (linkmap) pour l’exemple de ci-dessus
5.13 .end
La directive .end indique la fin du code source. Toutes les instructions, qui suivent .end, sont ignorées par
l’assembleur. La directive .end est facultative avec l’assembleur ARM_GNU.
Exemple :
mysub:
...
MOV pc, lr @ dernière instruction
.end @ les instructions suivantes seront ignorées
5.14 Les opérations assembleur

De nombreux opérateurs sont mis à disposition pour exécuter des calculs à l’intérieur des opérandes. Ces
derniers sont essentiellement utilisés pour le calcul des offsets et des adresses de stockage, comme par exemple
pour les accès Tableaux. Les opérandes de ces opérateurs doivent posséder des valeurs, qui sont fixes durant le
processus d’assemblage. Par conséquent, ces derniers doivent être des constantes.
L’assembleur GCC connaît deux opérateurs signés, qui sont équivalent à ceux de C.
Opérateur Descriptions
- Inversion arithmétique (complément à 2)
~ Inversion binaire (complément à 2)
Tableau 37: Les opérateurs signés de l’assembleur
Les opérateurs arithmétiques et logiques sont décrits dans le Tableau 38. La priorité de ces opérateurs est
identique à celle des opérateurs ANSI-C.

Opérateur Priorité Description

/ 1 Division (entier)
* 1 Multiplication
% 1 Reste de la division (Modulo)
<< 1 Décalage vers la gauche
>> 1 Décalage vers la gauche
| 2 OU binaire
^ 2 OU Exclusif binaire
& 2 ET binaire
! 2 NON binaire
+ 3 Addition
- 3 Soustraction
== 3 Egalité
<> 3 Inégalité
< 3 Plus petit que
> 3 Plus grand que
<= 3 Plus petit que ou égalité
>= 3 Plus grand que ou égalité
&& 4 ET logique
|| 5 OU logique
Tableau 38 : Les opérateurs assembleur
Le résultat d’une opération de comparaison est toujours une valeur numérique. La valeur -1 représente ainsi vrai
et celle 0 faux. Toutes les opérations de comparaisons permettent de comparer des valeurs non signées.
Les opérations logiques livrent une valeur 1 correspond à vrai et celle 0 à faux.
Les calculs arithmétiques ne sont pas possibles si les opérandes se situent dans des sections différentes.
5.15 Les structures de contrôle en assembleur

Les structures de contrôle en assembleurs sont destinées au processus d’assemblage. Il est ainsi possible de
générer des versions différentes du code en fonction de conditions prédéterminées. Par exemple du code
supplémentaire peut être inséré dans le programme afin de pouvoir le tester. Ce code, qui n’est plus nécessaire
dans la version finale du programme, peut ainsi être facilement omis.
5.15.1 L’assemblage conditionnel avec .if

La directive .if permet d’assembler de façon conditionnelle le bloque de code, qui suit cette dernière jusqu’aux
directives .endif ou .else. Le code n’est ainsi assemblé, que si la condition se réalise.
La syntaxe de .if est la suivante :
.if <ExpressionLogique>
...
{.else}
.endif
Lorsque la condition de l’expression « ExpressionLogique» est vrai, le bloque .if sera assemblé. Si non
c’est le bloque .else, qui sera assemblé.
Exemple :
La macro suivante permet de décaler a, soit vers la gauche ou vers la droite, en fonction du signe de b.

.macro SHIFTLEFT a, b
.if \b < 0
MOV \a, \a, ASR #-\b
.else
MOV \a, \a, LSL #\b
.endif
.endm
5.15.2 L’assemblage conditionnel avec .ifdef

La directive .ifdef ne permet d’assembler un bloc de code que si son symbole existe. Par conséquent, ce
dernier doit être défini auparavant en tant qu’étiquette (label), avec les directives .set, .equ ou =.
La syntaxe de .ifdef est la suivante :
.ifdef <Symbole>
...
{.else}
.endif
Exemple :
Du code supplémentaire peut être inséré dans un programme, afin de pouvoir le tester. Dans l’exemple suivant,
le point d’arrêt n’est exécuté que si le symbole DEBUG a été défini auparavant.
.set DEBUG, 1
start:
LDR r0, =0x80
.ifdef DEBUG
BKPT
.endif
LDR r1, =0x80
5.15.3 L’assemblage conditionnel avec .ifndef

La directive .ifndef ne permet d’assembler un bloc de code que si son symbole n’existe pas. Le principe de
fonctionnement est identique à celui de .ifdef
La syntaxe .ifndef est la suivante :
.ifndef <Symbole>
...
{.else}
.endif
5.16 La définition de macro avec .macro

La directive .macro permet de définir un symbole pour une certaine quantité de texte. Cette création de texte
peut également être paramétrée. La directive macro n’agit qu’au niveau substitution de texte. Toutes les
définitions de macro doivent se terminer avec la directive .endm.
La syntaxe de .macro est la suivante :

.macro <Nom> {<arg1>} {, <arg2>} {, <arg3>} ... {, <argN>}

{BlocCode}
.endm
Le nom doit remplir les critères, qui régissent les noms des symboles. La convention veut que l’on définisse les
noms de macro avec des majuscules. Les arguments représentent formellement les paramètres, comme pour une
fonction C. L’accès à ces paramètres doit s’effectuer dans la macro avec un caractère back slash ‘\’. Une
instruction macro peut être quittée avec la directive .exitm. Cela est toutefois en désaccord avec la
programmation structurée, mais peut dans certain cas simplifier le codage de la macro.
Exemple :
.exitm permet de définir une macro sans la directive .else.
Avant:
r0 = 0x80
r1 = 0x80
.macro SHIFTLEFT a, b
.if \b < 0
MOV \a, \a, ASR #-\b
.exitm
.endif
MOV \a, \a, LSL #\b
.endm
SHIFTLEFT r0, 2
SHIFTLEFT r1, -2
Après:
r0 = 0x200
r1 = 0x20
Exemple :
La macro ADR est une macro prédéfinie pour charger l’adresse des objets. Cette dernière exécute
automatiquement le calcul de l’offset par rapport au registre du compteur de programme pc. La macro peut être
utilisée comme une instruction du processeur.
La syntaxe de la macro ADR est la suivante:
ADR Rd, <Label>
Exemple :
Le chargement de l’adresse de base d’un Tableau peut être effectué très simplement avec la macro :
.text
...
ADR r0,Tab
...
.data
Tab: .word 0, 1, 2, 3, 4

5.17 Les structures de répétitions en assembleur

Les structures de répétition peuvent être considérées comme des macros, parce que ces derniers génèrent
également du texte. Les structures de répétitions permettent d’insérer un bloc de code plusieurs fois dans le
programme. Ce bloc peut être composé d’instructions ou de caractères. L’assembleur GNU met à disposition
pour cela les directives suivantes :
 .rept (répétition)
 .irp (répétition indéfinie)
5.17.1 La répétition avec .rept

La directive .rept permet d’insérer un bloc de code un certain nombre de fois.
La syntaxe de .rept est la suivante :
.rept <Quantite>
{BlocCode}
.endr
Exemple :
Les mots 0x55AA55AA, 0x00000000, 0xAA55AA55, 0x11111111 doivent être insérés 16 fois dans la
mémoire. La directive .rept permet de réaliser cela de façon compacte :
.rept 16
.word 0x55AA55AA
.word 0x00000000
.word 0xAA55AA55
.word 0x11111111
.endr
Le débuggeur permet de voir, comment ces valeurs ont été déposées dans la mémoire :

Figure 74 : La déposition de structure dans la mémoire avec .rept
Exemple :
.rept permet également de générer un Tableau contenant des valeurs pré calculées à l’aide de symbole.
L’exemple suivant montre la construction d’un Tableau du type byte contenant des valeurs allant de 0 à 255.
.set L1, 0 @ L1 is a local symbole with a start value

.rept 256
.byte L1
.set L1, L1+1
.endr
5.17.2 La répétition paramétrée avec .irp

La directive .irp permet d’exécuter une suite d’instruction avec plusieurs opérandes. Cette directive est en
quelque sorte une version simplifiée d’une macro avec un nombre de paramètres variable. Le premier paramètre
est le symbole de l’opérande. Ensuite suivent un certain nombre de paramètres, qui seront utilisés l’un après
l’autre dans le bloc de code.
La syntaxe de .irp est la suivante :
.irp <Symbole> {,<Valeur>}{,< Valeur >} ...

{BlocCode}
.endr
Les paramètres « Valeur » doivent être des valeurs entières.
Exemple :
La directive .irp permet de répéter un bloc en fonction d’une liste de paramètres. Le code suivant additionne

tous les paramètres au registre r0 à l’aide du registre r1.
.irp param, 1, 2, 3, 4
MOV r1, #\param
ADD r0, r0, r1
.endr
La macro est étendue à l’assemblage du programme :
.irp param, 1, 2, 3, 4
MOV r1, #\param
ADD r0, r0, r1
.endr
MOV r1, #1 @ 0x1

ADD r0, r0, r1
MOV r1, #2 @ 0x2
ADD r0, r0, r1
MOV r1, #3 @ 0x3
ADD r0, r0, r1
MOV r1, #4 @ 0x4
ADD r0, r0, r1
Figure 75 : Extension de la macro .irp de l’exemple de ci-dessus

Informtique 3 Les sous routines
6 Les sous routines
6.1 Introduction
Les sous routines sont des sous-programmes en assembleur. Ils correspondent, par conséquent, aux fonctions ou
aux procédures des langages de programmation évolués.
Une sous routine possède les propriétés suivantes :

 Une sous-routine est une séquence d’instructions, avec une fonctionnalité et une interface (paramètres).
 Une sous-routine est une boîte noire pour la fonction appelante, qui doit respecter scrupuleusement
l’interface (Information Hiding).
 Les sous-routines peuvent être appelées plusieurs fois.
Les sous routines possèdent les avantages suivants :

 Modularité : Une application peut être divisée en plusieurs sous routines. Ce qui augmente sa lisibilité et
facilite son entretient.
 Travail d’équipe : La programmation peut être effectuée par plusieurs personnes.
 Réduction de la taille du programme : Une séquence de codes, qui est exécutée plusieurs fois, n’est
stockée qu’une seule fois dans la mémoire.
 Augmentation de la qualité : Les sous routines permettent de mieux tester et documenter le programme.
 Reprise : Les sous routines peuvent être également utilisés dans des autres projets. Ce qui réduit l’effort
de programmation.
Dans les langages de programmation évolués, le compilateur gère l’appel des sous programmes (callee) à partir
des programmes appelants (caller). Cela n’est malheureusement pas le cas dans les langages de programmation
en assembleur : ici le programmeur est l’unique responsable du déroulement de cet appel. Typiquement, les
problèmes suivants doivent être considérés par ce dernier :
 Appel de la sous routine et retour depuis cette dernière
 Echange de données entre la fonction appelante et la sous routine (transfert des paramètres)
 Les variables locales
6.2 Appel et retour de sous routine

6.2.1 Appel de sous routine
Programme principal Sous routine 1
subr1:
bsr subr1 1. instruction

instruction suivante instruction suivante
n. instruction
retour
Figure 76 : Appel d’une sous routine

Dans l’exemple de la Figure 76, la sous-routine subr1 est appelée à partir du programme principal. A la fin de
l’exécution subr1, le programme retourne dans la routine principale, afin d’y exécuter les instructions

suivantes.
Dans l’architecture ARM, les appels de sous routine sont réalisés avec les instructions « Branch-and-Link »
(BL). Cette instruction initialise le compteur de programme (PC) avec l’adresse de départ de la sous routine et
stocke simultanément l’adresse de retour (l’adresse de l’instruction qui suit l’appel de la sous routine dans le
programme appelant) dans le registre de reliage (LR).
main:
BL subr1 @ branch to subr1 & copy the return address in LR
... @ next instruction
subr1:
... @ instructions of the subroutine
MOV pc, lr @ return from the subroutine
L’instruction « MOV PC, LR » est mise à disposition pour le retour depuis la sous routine. Le contenu du
registre de reliage (l’adresse de retour) est ainsi copié dans le compteur de programme. Cette opération peut
également être définie de la manière suivante : « MOV R15, R14 ».
La sous routine ne devrait pas modifier le contenu du registre de reliage, car ce dernier contient l’adresse de
retour. En particulier, la sous routine ne devrait pas appeler d’autre sous routine, sans sauver préalablement le
contenu du registre de reliage.
6.2.2 Appel emboîté de sous routine et la pile (stack)

Une sous routine peut à son tour appeler une autre sous routine. Cet appel est illustré à l’aide de l’exemple
suivant. Le programme principal appelle la sous routine « subr1 », qui appelle une seconde sous routine
« subr2 ».
Programme principal Sous routine 1 Sous routine 2
subr1 subr2
bsr subr1 1. instruction 1. Instruction

i t
Instruction bsr subr2
suivante
Instruction
suivante
n. instruction n. Instruction
i t
retour retour
Figure 77: Appel emboîté de sous routine
Une sous routine peut s’appeler elle-même, générant ainsi un code récursif. Avec les codes récursifs, il faut faire
attention à la condition d’arrêt. Si non, la pile (stack) pourrait déborder.
Les adresses de retour doivent être systématiquement déposées sur la pile (stack), avec les appels emboîtés de
sous routines. Pour cela il faut :
a) Définir le domaine de la pile avec un le plan de mémoire
b) Initialiser de la pile

La pile est une structure de donnée dynamique, qui fonctionne selon le principe « Last In, First Out ». Les
opérations suivantes sont mises à disposition pour gérer cette dernière :
 Initialisation
 Push (poser un élément sur la pile)
 Pop (chercher le dernier élément de la pile)
Un nouvel élément est posé sur la pile avec l’opération « push ». L’élément, qui a été déposé en dernier sur la
pile, peut être recherché avec l’opération « pop ». Ces opérations modifient la taille de la pile.
Début de la pile
1. Elément
2. Elément
3. Elément
Pointeur de pile
push pop
Figure 78 : La pile (stack)
Le pointeur de pile (stack pointer) adresse la fin de la pile, c. à d. l’endroit où la prochaine opération aura lieu.
Le registre R13 sert de pointeur de pile dans les processeurs ARM. Il est également possible de définir « SP » au
lieu de R13.
Les piles peuvent être implémentées de différentes manières :

 La pile peut croître « vers le bas » (descending). Dans ce cas les données sont déposées sur la pile en
décrémentant le pointeur de la pile. La pile peut égalent croître « vers le haut » (ascending). Dans ce cas
les données sont déposées sur la pile en incrémentant le pointeur de pile.
 Le pointeur de pile peut adresser soit la dernière case utilisée, c'est-à-dire l’endroit où le dernier élément
a été déposé sur la pile (« full )»); ou la prochaine case libre, c'est-à-dire l’endroit où le prochain
élément peut être déposé sur la pile (« empty )»).
Par conséquent, il est important que la même version de la pile soit utilisée par le compilateur et le programmeur
en assembleur. Le standard d’appel de procédure ARM (ARM Procedure Call Standard, APCS, voir chapitre
6.5) spécifie pour la pile le mode de fonctionnement « full descending ». Les opérations push sont alors
réalisées avec les instructions STR (sauvegarder uniquement du contenu du registre de reliage) et STMFD ("store
multiple full descending", afin de pouvoir sauver plusieurs registres simultanément). Les opérations pop peuvent
être réalisées soit avec les instructions LDR (recherche uniquement du contenu du registre de reliage) et LDMFD
("load multiple full descending", afin de rechercher le contenu de plusieurs registre à partir de la pile).
L’instruction STMDB ("store multiple decrement before") peut être également utilisée au lieu de STMFD. Car les
deux instructions sont équivalentes. Pour les même raisons, l’instruction LDMFD peut être remplacée par
LDMIA ("load multiple increment after").
Le code du programme principal et de la sous-routine subr1 de la Figure 77 devient ainsi :
main:
BL subr1 @ branch to subr1 & copy return address in LR
... @ next instruction

subr1:
STR lr, [sp, #-4]! @ push lr on the stack
... @ code subroutine 1
BL subr2 @ call subroutine 2
LDR pc, [sp], #4 @ return: pop return adress from stack
L’instruction STR décrémente d’abord le pointeur de pile de 4 bytes (la pile croît vers le bas). L’adresse de
retour du registre LR est ensuite déposée sur la pile.
Point de départ de l’exemple: Opérations de pile au sein de subr1:

PC = 0x2000,
0x3200 lr auf
adresse de la sous routine 0x1000, 0x00002004 2 Stack
0x31FC
SP = 0x3200 1
sp-4
Adresse Code
0x2000 BL subr1
0x2004 Next instruction
...
subr1:
0x1000 STR lr, [sp, #-4]!
...
Figure 79: Déposition de l’adresse de retour sur la pile
L’opération contraire est réalisée à la fin de la sous routine : L’adresse de retour est d’abord transférée depuis la
pile dans le registre compteur de programme pc. Le pointeur de pile est ensuite corrigé de 4 bytes vers le haut.
Le programme retourne finalement dans la routine appelante. C'est-à-dire, qu’il exécute l’instruction qui suit
l’appel de la sous routine. Cette dernière se situe dans l’exemple de ci-dessus à l’adresse 0x2004.
L’initialisation de la pile exige d’une part la définition d’un bloc de mémoire et d’autre part l’initialisation du
pointeur de pile. L’extrait de code suivant illustre cela pour le pointeur de pile principale (MSP) :
Exemple :
Manuscrit du relieur (stm32f4_flash.map) :
/* highest address of the main mode stack */
_estack = 0x20002000
Code de démarrage (startup.s) :

.section .isr_vector, "a"
g_pfnVectors:
.word _estack
.word Reset_Handler
.word NMI_Handler
.word HardFault_Handler
.word MemManage_Handler
.word BusFault_Handler
.word UsageFault_Handler
…
L’adresse de base de la pile principale (main stack) est définie dans le manuscrit du relieur (link script). Du fait
que selon le standard APCS la pile (stack) doit croître vers le bas, cette adresse de base correspond à l’adresse de
la fin du bloc de mémoire réservé pour la pile.
L’adresse de base de la pile est le premier vecteur du tableau de vecteurs d’interruption (voir chapitre 7.7). Cette
dernière est copiée automatiquement dans le registre MSP Au démarrage du système (voir chapitre 10.1).

Remarque : Les processeurs ARM peuvent travailler avec des piles différentes (voir chapitre 2.5: Le modèle des
registres). Le Cortex-M4 possède encore un pointer de pile de processus (PSP), qui n’est pas initialisé dans notre
code de démarrage.
Les instructions pour les appels et les retours de sous routines sont fournies dans le Tableau suivant :
Instruction Syntaxe Opération

Branch-and-Link BL subr_name lr  Adresse de retour
pc  pc + distance de saut
push simple STR lr, [sp, #-4]! sp  sp – 4
Stack  Adresse de retour
push multiple STMFD sp!, {r0-r2, lr} sp  sp – n
Variante: STMDB Stack  Adresse de retour + registre de travail
pop simple LDR pc, [sp], #4 pc  Adresse de retour
+ Adresse de retour sp  sp + 4
return
pop multiple LDMFD sp!, {r0-r2, pc} registre de travail  Stack
+ Adresse de retour Variante: LDMIA sp  sp + n
return
Tableau 39 : Opération de pile pour les appels et les retours de sous routines.
La pile de l’exemple de la Figure 77 contient les valeurs suivantes :

a) Contenu de la pile, lorsque le programme se trouve dans la routine principale
b) Contenu de la pile, lorsque le programme se trouve dans « subr1 »
c) Contenu de la pile, lorsque le programme se trouve dans « subr2 »
sp return return
0x3200 Adr 1 Adr 1
sp return
0x31FC Adr 2
sp
0x31F8
Stack a) b) c)
Figure 80 : Déposition des adresses de retour sur la pile

6.3 La sauvegarde du contenu des registres

Considérons le code suivant, qui appelle la sous routine « subr3 » 10 fois à partir d’une boucle.
Programme principale :
start: MOV r4, #0 @ initialize loop variable r4
loop: BL subr3 @ branch to subroutine
ADD r4, r4, #1 @ increment loop variable
CMP r4, #10 @ check if 10 loops done
BNE loop @ no  branch to label loop
...
Sous routine 3 :
subr3: STR lr, [sp, #-4]! @ push lr on the stack
...
MOV r4, #0 @ modify r4
...
LDR pc, [sp], #4 @ return
Le problème de cette séquence de code est que le contenu du registre r4, qui est utilisé dans le programme
principal pour le stockage de la variable de compteur, est modifié dans la sous routine subr3 !
Dans ce cas la règle est le principe des contributions : Les contenus des registres, qui sont modifiés par la sous-
routine, doivent être sauvés au début et restitués à la fin de cette dernière (exception voir chapitre 6.5). Les
instructions du Tableau 39 sont mises à dispositions pour ces opérations. Par conséquent, dans l‘exemple de ci-
dessus, la sous routine subr3 doit également sauvegarder le contenu du registre r4.
La sous routine subr3 doit être modifié de la manière suivante :

subr3:
STMFD sp!, {r4, lr} @ push registers to stack
...
MOV r4, #0 @ modify r4
...
LDMFD sp!, {r4, pc} @ pop registers from stack
Remarque : L’instruction LDMFD copie directement l’adresse de retour dans le registre pc.
6.4 Le transfert des paramètres

Le transfert de paramètres entre le programme appelant et les sous routines peut être effectué de 2 manières :
1. Transfert de paramètres à l’aide de registres
2. Transfert de paramètres à l’aide de la pile (stack)
Les fonctions C et les sous routines en assembleur peuvent posséder plusieurs paramètres. Il est donc important
que le compilateur C et le programmeur en assembleur respecte les mêmes directives. Le standard d’appel de
procédure ARM (ARM Procedure Call Standard, APCS) fixe les règles de transmission des paramètres pour les
processeurs ARM (voir chapitre 6.5) :
Les paramètres sont gérés à l’aide d’une liste. Les 4 premiers paramètres sont transmis avec les registres r0
à r3. Les autres paramètres sont transmis, dans un ordre inversé, à l’aide de la pile.
6.4.1 Le transfert de paramètres à l’aide de registre

Il existe fondamentalement deux types de transfert de paramètres :
Call by Value:

Une copie de la valeur originale est transmise en tant que paramètre à l’aide des registres (r0 à r3). Dans ce cas
la sous routine ne pas accéder à la variable originale.
Exemple: programme principale :

ADR r0, variable @ r0 points to address of variable
LDR r0, [r0] @ copy value of variable into r0
BL mySubr @ call subroutine, parameter is in r0
Call by Reference:
L’adresse de la variable est transmise en tant que paramètre à l’aide des registres (r0 à r3). Dans ce cas la sous-
routine peut accéder à la variable originale.
Exemple: programme principale :

ADR r0, variable @ r0 points to address of variable
BL mySubr @ call subroutine, parameter is in r0
Exemple :
Considérons comme exemple une sous routine « sum », qui possède 3 paramètres. Cette dernière peut être
définie da la manière suivante en C :
int op1 = 2;
int op2 = 5;
int res;
void sum (int v1, int v2, int* res) {

*res = v1 + v2;
}
void main (void) {

sum (op1, op2, &res);
}
Le programme appelant peut être défini en assembleur de la manière suivante :

op1: .word 2 @ 1st operand
op2: .word 5 @ 2nd operand
res: .word 0 @ result
main:
ADR r0, op1 @ copy address op1 into r0
LDR r0, [r0] @ read value op1, 1st parameter by value
ADR r1, op2 @ copy address op2 into r1
LDR r1, [r1] @ read value op2, 2nd parameter by value
ADR r2, res @ read address res, 3rd parameter by reference
BL sum
La sous-routine sum peut être définie en assembleur de la manière suivante :

 Calcul la somme des deux opérandes
 r3 est utilisé pour le stockage de la valeur intermédiaire
sum:
STR lr, [sp, #-4]! @ push lr
ADD r3, r0, r1 @ temp = op1 + op2
STR r3, [r2] @ *res = temp
LDR pc, [sp], #4 @ pop lr, return
Remarque : Le standard APCS n’exige pas de sauver le contenu du registre r3 à l’aide de la pile (voir chapitre

6.5).
6.4.2 Le transfert de paramètres avec la pile

Les 4 premiers paramètres sont transmis avec les registres r0 à r3. Les paramètres suivants sont transmis dans
un ordre inverse à l’aide de la pile.
Considérons comme exemple la sous routine « super_sum », qui possède l’interface C suivant :
int super_sum (int p1, int p2, int p3, int p4, int p5, int p6);
Cette sous routine ne retourne pas le résultat de façon « call by reference », mais à l’aide d’une valeur de
restitution. Cette restitution s’effectue avec le registre r0, selon le standard APCS.
Le code de la sous-routine « super_sum » peut être implémenté de la manière suivante :

 r4 est utilisé pour le stockage temporaire du résultat
 r5 est utilisé comme tampon pour la déposition momentanée des paramètres transmis avec la pile
 r4 et r5 doivent être sauvegardés à l’aide de la pile
super_sum:
STMFD sp!, {r4, r5, lr} @ push r4, r5 and lr
MOV r4, r0 @ temp = p1
ADD r4, r1 @ temp += p2
LDR r5, [sp, #12] @ buffer = p5
LDR r5, [sp, #16] @ buffer = p6
MOV r0, r4 @ copy return value to r0
LDMFD sp!, {r4, r5, pc} @ pop r4, r5 and lr, return
Le contenu de la pile pour l’appelle de la sous routine « super_sum » est le suivant :
SP 6. 6.
0x3200 Operan Operan
d d
5. 5. 16
Operan Operan
d d
12
SP
lr
0x31F8
r5 8
r4 4
SP 0
0x31EC
Figure 81 : Transfert de paramètres à l’aide de la pile

a) Avant l’appelle de la sous-routine super_sum et la déposition des paramètres sur la pile

b) Après l’appelle de la sous routine, les paramètres 5 et 6 ont été déposé sur la pile
c) Dans la sous routine après l’instruction STMFD (push)
6.5 APCS
Le standard d’appel de procédure ARM (ARM Procedure Call Standard, APCS) fixe l’utilisation des registres de
la CPU. Cette convention est importante, afin que les compilateurs et les assembleurs puissent utiliser les mêmes
conventions pour la transmission des paramètres, la sauvegarde des registres etc.
Registre Nom APCS Brève description

r0 a1 Argument 1 / valeur de restitution à 32 bits/ registre scratch
r1 a2 Argument 2 / valeur de restitution à 64 bits / registre scratch
r2 a3 Argument 3 / registre scratch
r3 a4 Argument 4 / registre scratch
r4 v1 Variable registre 1
r9 Sb / tr / v6 Dépend de la plateforme / Variable registre 6
r12 Ip Intra-Procedure-call / registre scratch
r13 Sp Pointer de pile (stack pointer)
r14 Lr Registre de reliage (link register)
r15 Pc Compteur de programme (Program-Counter)
Tableau 40 : Attribution de registre selon le standard APCS
APCS fournit les spécifications suivantes :
 Les registres r0 à r3 (a1 à a4) sont utilisés pour transmettre les arguments aux sous routines. Ces
dernières ne doivent pas conserver leur contenu. Par conséquent, ces registres peuvent être utilisés
comme registres scratch (volatiles, utilisables à souhait et qui ne doivent pas être sauvés dans par les
sous routine appelée). Attention : cela veut dire que les fonctions appelantes doivent considérer, que le
contenu de ces registres peut être modifié par l’appelle de la sous routine ! Le registre r0 est utilisé
pour le retour d’un résultat à 32 bits. Les registres r0 et r1 sont utilisés lorsque ce résultat est de 64
bits.
 Les registres r4 à r8 (v1 à v5) et les registres r10 et r11 (v7 et v8) peuvent être utilisés comme
registre de variable (mémoire intermédiaire). Ces registres doivent retrouver leur valeur d’origine à la
fin de la sous routine. Ils doivent par conséquent être sauvés au début de cette dernière (callee-saved),
voir chapitre 6.3.
 Le registre r9 dépend de la plateforme. Il peut être utilisé comme registre de base statique (static base,
sb) ou comme registre Thread (Thread register, tr). Si r9 n’est pas utilisé pour ces tâches, il peut être
utilisé comme registre de variable.
 Le registre r12 (ip, Interlink Pointer) peut être utilisé comme registre scratch entre les routines et les
sous routines.
 Le registre r13 est le pointeur de pile.
 Le registre r14 est le registre de reliage.
 Le registre r15 est le compteur de programme.

6.6 Définition de variable locales

Les variables locales sont souvent utilisés dans les langages de programmation évolués. Exemple en C :
void myFunc (void)

{
unsigned int myArray [10]; // 10 * 4 Byte local variable
...
...
}
Les variables locales sont définies normalement à l’aide des registres r4 à r8, r10 et r11. Lorsque des
variables locales supplémentaires sont nécessaires, il faut stocker ces dernières sur la pile. Dans ce cas une zone
de mémoire, dont la taille correspond au bloc de variables locales, est allouée sur la pile. Un registre de pointeur
de trame (Frame Pointer), qui est normalement le registre r11, est initialisé avec l’adresse de base de ce bloc.
Le code de la sous-routine « myFunc » peut être implémenté de la façon suivante :
myFunc:
STMFD sp!, {r11, lr} @ push r11 and return address, (1)
SUB sp, sp, #40 @ allocate 40 bytes local variable space (2)
MOV r11, sp @ r11 points to first local variable (3)
...
...
ADD sp, sp, #40 @ free local variable space
LDMFD sp!, {r11, pc} @ pop r11 and lr, return
Le stockage des variables locales à l’aide de la pile s’effectue de la manière suivante :
SP alt
lr
r11 alt
1
1
lokaler
Variablen-
bereich 3
2 SP neu r11 neu
Figure 82 : Déposition des variables locales sur la pile
La zone de mémoire contenant les variables locales peut être adressée à l’aide du pointeur de trame r11 et d’un
offset positif. Le programmeur est responsable du calcul correct de cet offset, comme ce fut le cas pour le
transfert des paramètres !
Le pointeur de trame adresse la partie inférieure la zone de mémoire contenant les variables locales. Toutefois,
ce pointeur peut être initialisé afin qu’il adresse la partie supérieur de cette zone. L’offset, pour pouvoir accéder
aux variables locales, doit alors être négatifs. Une autre variante est l’utilisation du pointeur de pile au lieu du
pointeur de trame pour adresser ces variables locales.
Lorsque des variables locales sont utilisées simultanément avec une transmission de paramètre avec la pile (voir
chapitre 6.4.2), les paramètres peuvent également être adressés avec le pointeur de trame au lieu du pointeur de
pile. Remarque : certain compilateur C initialise toujours un pointeur de trame, même si la sous routine n’utilise
pas de variables locales allouées sur la pile. Le code est ainsi un peu plus lent mais, par contre, le calcul des
offsets pour l’accès aux paramètres devient beaucoup plus simple.

6.7 Sources d’erreurs

Il faut faire attention aux opérations suivantes concernant l’appel et la terminaison des sous routines :
 Appeler les sous routines avec « BL » et non « B » !
 Terminer les sous routine en copiant l’adresse de retour dans le registre de compteur de programme pc
(soit directement depuis le registre de reliage lr ou depuis la pile)
 Lorsque la sous routine utilise des registres (mis à part les registres scratch), elle doit sauver leur
contenu sur la pile (faire attention à la succession des opérations de sauvetage, c. à d. que le registre qui
a été sauvé en dernier doit être repris en premier). Le nombre des opérations « pop » doit correspondre
au nombre des opérations « push ».
 Définir la pile suffisamment grande, afin que des dépassements de capacité ne puissent pas avoir lieu.
 Erreur de calcul des offsets des paramètres transmis à l’aide de la pile
Les erreurs de gestion de la pile génèrent toujours des chutes de programme, car les adresses de retour ne sont
plus justes !
6.8 Comparaison entre sous routine et macro

Le code de la sous-routine n’est déposé qu’une fois dans la mémoire, même si cette dernière est appelée depuis
plusieurs endroits du programme. Par contre, le code de la macro est déposé à chaque appel de cette dernière
dans la mémoire : Ce qui augmente d’une part la taille du programme et empêche d’autre part de définir des
macros récursives.
Il s’en suit la question : pourquoi utilise-t-on les macros. La réponse est dans le comportement temporel : un
appel de sous routine avec l’instruction « BL » et le retour depuis cette dernière nécessite plus de temps (même si
cela ne concerne que deux instructions). Dans les applications, qui sont très critiques au niveau temps, cette
diminution de la vitesse d’exécution favorise la macro.
Dans des applications standards, il faut utiliser en générale des sous routines. Alors que dans les applications, qui
sont critique au niveau temps, il faut utiliser des macros.
Remarque: Un bon design software et des bons algorithmes sont beaucoup plus efficaces pour la performance du
processeur, que le remplacement systématique des sous routines par des macros.

Informtique 3 Les interruptions et les exceptions
7 Les interruptions et les exceptions

Les interruptions ont été introduites durant le module « Informatique 2 » dans le cadre de la programmation
proche du hardware en C (firmware). Ce chapitre traite les interruptions et les exceptions (interruptions générées
par des erreurs du programme) au niveau de l’assembleur et du hardware.
7.1 Introduction
Les exceptons sont des évènements qui peuvent survenir durant l’exécution d’un programme et qui requiert un
traitement par ce dernier. Les exceptions ARM peuvent être réparties en 3 catégories :
1. Les exceptions qui surviennent durant l’exécution d’une instruction. Ce type d’exception apparaît de
façon synchrone au déroulement au programme. Cette catégorie comprend les exceptions suivantes :
 Les interruptions software
 Les instructions non définies (l’instruction à exécuter est inconnue ou destinée à un
coprocesseur non disponible)
 Prefetch Abort (exception générée à cause d’une erreur d’accès mémoire durant la lecture de
l’instruction)
2. Les exceptions qui apparaissent comme effet secondaire à une instruction. Ce type d’exception apparaît
également de façon synchrone au déroulement au programme. Les exceptions, qui composent cette
catégorie, sont les suivantes :
 Data Abort (exception générée à cause d’une erreur d’accès mémoire durant la lecture ou
l’écriture d’une donnée)
3. Les exceptions générées de façon externe. Ce type d’interruption apparaît de façon asynchrone au
déroulement du programme. C’est à dire que le programme peut être interrompu à n’importe quel
instant. Les exceptions qui composent cette catégorie sont les suivantes :
 Reset (mise sous alimentation, appui de la touche reset ou activation du « watch dog »)
 Les interruptions hardware (Interrupt Request IRQ)
Lorsqu’une exception survient dans un système, ce dernier doit appeler une sous-routine pour son traitement.
Dans ce contexte on parle de « traiteur d’exception » (Exception Handler) ou pour le cas d’interruption hardware
de « routine de service d’interruption » (Interrupt Service Routine : ISR).
Le déroulement du programme est identique pour les trois catégories d’interruption : le programme principal est
interrompu et l’exception est traitée par le traiteur d’exception. Une description exacte du déroulement est
donnée aux chapitres 7.7et 7.8.
Programme principale Traiteur d’exception
Première
instruction
Exception
Instruction
courante
Instruction
suivante
Dernière
instruction
Figure 83 : Déroulement du programme à la suite d’une exception

7.2 Les interruptions

Les interruptions peuvent être partagés en deux catégories : les interruptions hardwares et softwares.
Les interruptions hardware :

Les interruptions hardware surviennent de façon asynchrone au déroulement du programme. Ces dernières sont
des outils très importants pour accomplir les requêtes temps réel. Les interruptions hardware sont toujours
générées par des composants périphériques. Par exemple le timer, l’interface sérielle ou un port d’entrée
quelconque. Les éventuelles sources d’interruptions dépendent donc du processeur et de ses composants
périphériques.
Exemple d’interruption hardware :

Le programme d’un microprocesseur commande un système embarqué contenant un affichage LCD, des touches
et une interface sérielle. Il existe deux approches pour réaliser la lecture des données à partir des touches ou de
l’interface sérielle :
1. Les touches et l’interface sérielle sont lues périodiquement (polling). Le programme test de façon
cyclique, par exemple toutes les 10 millisecondes, si une touche a été appuyée ou si l’interface sérielle a
reçu un nouveau caractère. Cette approche présente néanmoins les défauts suivants :
 La lecture périodique des entrées nécessite beaucoup de temps de calcul. La plupart du temps
le programme constatera qu’aucune touche n’a été appuyée et qu’aucun caractère n’a été reçu.
 Un évènement peut être perdu à cause de la période du polling. Par exemple : si la lecture des
touches ne s’effectue que toutes les secondes et qu’une touche n’a été appuyée que pendant
une demi seconde.
 Le temps nécessaire pour réagir à un évènement correspond, au pire des cas, à la période de
polling.
2. Les touches et l’interface sérielle génèrent des requêtes d’interruption, lorsqu’elles doivent transmettre
une nouvelle information au programme. Cette approche présente les avantages suivants :
 Temps de réaction très rapide aux évènements
 Utilisation de la CPU qu’en cas de nécessité
Les interruptions software :

Les interruptions software (SVC) sont traitées de la même manière que les interruptions hardware. Ces dernières
surviennent toutefois de façon synchrone au déroulement du programme. Par conséquent, les interruptions
software représentent quelque chose entre un appel de sous-routine et un traitement d’interruption.
Les interruptions software sont souvent utilisées pour appeler des fonctions du système d’exploitation. Car ces
dernières font entrer le microprocesseur dans le mode superviseur. Ces fonctions ont ainsi la possibilité
d’accéder à tous les registres.
Le chapitre 4.6.2 fournit de plus ample informations sur les interruptions software et l’instruction SVC.

7.3 Les exceptions/interruptions du STM32F407xx

Le microcontrôleur STM32F407xx possède 16 exceptions/interruptions au niveau système et 82 interruptions
hardware. Les principales sources d’exception/interruption, leur priorité et l’adresse de leur vecteur de traitement
sont fournies dans le Tableau 41. Le tableau complet avec les sources d’interruption restantes est fournie en
annexe C.
Position
Priorité
Type de Adresse du
Acronyme Description
priorité vecteur
-16 _estack End of the main stack 0x0000_0000

-15 -3 Fix Reset 0x0000_0004
-14 -2 Fix NMI Non Maskable Interrupt 0x0000_0008
-13 -1 Fix HardFault All class of fault 0x0000_000C
-12 0 Programmable MemManage Memory management 0x0000_0010
-11 1 Programmable BusFault Pre-fetch fault, memory access fault 0x0000_0014
-10 2 Programmable UsageFault Undefined instruction or illegal state 0x0000_0018
- - - - Reserved 0x0000_001C
…
0x0000_002B
-5 3 Programmable SVCall System service call via SVC instruction 0x0000_002C
-4 4 Programmable Debug Monitor Debug Monitor 0x0000_0030
- - - - Reserved 0x0000_0034
-2 5 Programmable PendSV Pendable request for system service 0x0000_0038
-1 6 Programmable SysTick System tick timer 0x0000_003C
0 7 Programmable WWDG Window Watchdog interrupt 0x0000_0040
… … … … … …
81 88 Programmable FPU FPU global interrupt 0x0000_0184
Tableau 41 : Les exceptions/interruptions du STM32F407xx, source [Cortex-

M4_Devices_GenUserGui]
7.4 Les propriétés des exceptions/interruptions

Les interruptions possèdent les propriétés suivantes :
1) Les sous-routines sont appelées directement avec les instructions de branchement BL, alors que les
routines de service d’interruption (ISR) sont appelées indirectement par des évènements externes. Le
« Tableau des vecteurs d’exception » (vector table) contient les adresses des différents traiteurs
d’exception (voir chapitres 7.7et 7.8).
2) L’apparition d’une exception/interruption engendre une changement de mode de fonction du Thread au
Handler.
3) Les exceptions/interruptions peuvent être activées ou masquées (voir chapitre 7.6)
4) Les exceptions/interruptions possèdent des priorités différentes (voir chapitre 7.5)

7.5 L’activation et le masquage des interruptions

Dans la plupart des processeurs, les exceptions/interruptions peut être activées (enabled) ou désactivées
(disabled). Cela peut être réalisé à l’aide de registres spécifiques.
L’activation et le masquage des exceptons/interruptions peuvent être réalisés en deux étapes dans les processeurs
Cortex-M4 (voir Figure 84). Dans un premier temps, les exceptions/interruptions peuvent être activées ou
désactivées collectivement au niveau cœur du Cortes-M4-Cores. Dans un deuxième temps, ces dernières peuvent
être activées ou désactivées individuellement au niveau du contrôleur d’interruption imbriqué (Nested Vectored
Interrupt Controller : NVIC).
NVIC Cortex-M4
Core
IRQ
Interrupt
IRQ [82] treatment
IRQ #
ISERx IPRx
ICERx
Figure 84: Activation et masquage des exceptions/interruptions
Dans le cœur du processeur Cortex-M4, les exceptions/interruptions peuvent être activées ou désactivées
collectivement avec les bits PRIMASK et FAULTMASK. Ces bits de commande se situent dans les registres
PRIMASK respectivement FAULTMASK.
Le bit PRIMASK permet de masquer toutes les exceptions/interruptions avec une priorité configurable (voir
Figure 85). Cela représente toutes les exceptions/interruptions du Tableau 41 à partir du numéro de priorité 0
(Memory management). Un 1 siginifie que ces exceptions/interrutions sont masquées et un 0 qu’elles ne les sont
pas.
Figure 85 : Le registre PRIMASK
Le bit FAULMASK est prévu pour le masquage de toutes les 82 interruptions hardware périphériques (voir Error!
Reference source not found.). Cela représente toutes les exceptions/interruptions du Tableau 41 à partir du
numéro de position 0 (Window Watchdog interrupt).
Figure 86 : Le registre FAULTMASK
Les 82 interruptions hardwares périphériques peuvent être activées ou désactivées individuellement avec les
registres « Interrupt Set-Enable » (ISER0 à ISER7) respectivement « Interrupt Clear-Enable » (ICER0 bis
ICER7) du NVIC. L’affectation des bits de ces derniers est la suivante :

Figure 87 : Affectation des bits dans les registres ISERx (adresse de base : 0xE000E100),
source [Cortex-M4_Devices_GenUserGui]
Figure 88 : Affectation des bits dans les registres ICERx (adresse de base : 0xE000_E180),
source [Cortex-M4_Devices_GenUserGui]
7.6 La priorité des exceptions/interruptions

Les questions suivantes apparaissent lorsque plusieurs exceptions surviennent simultanément :
 Quelle exception sera traitée en premier ?
 Est que les traiteurs d’exception peuvent-ils être interrompus par d’autres exceptions ?
La plupart des contrôleurs possèdent des exceptions/interruptions priorisées ou partiellement priorisables. Le

processeur Cortex-M4 permet également de programmer les priorités des exceptions/interruptions avec les
registres IPR0 à IPR59 du NVIC (voir Figure 89). Ces registres contiennent des champs de priorité composés
de 8 bits pour toutes les exceptions/interruptions dont la priorité est programmable. Cela représente toutes les
exceptions/interruptions du Tableau 41 à partir du numéro de priorité 0 (Memory management). Des niveaux de
priorité entre 0 (priorité la plus grande) et 255 (priorité la plus petite) peuvent ainsi être fixées avec chaque
champ de priorité.

Figure 89 : Affectation des bits des registres IPRx (adresse de base : 0xE000_E400),
source : [Cortex-M4_Devices_GenUserGui]
Ce qui de spécial avec les processeurs Cortex-M4, c’est que les champs de priorité sont composés de bits de
priorité principale (preempted or group priority bits) et de bits de priorité complémentaire (non preempted or sub
priority bits). Une exception/interruption de priorité principale supérieure peut interrompre le traitement d’une
exception/interruption de priorité principale inférieure (preemption). La priorité complémentaire n’intervient que
si deux exceptions/interruptions de priorité principale similaire apparaissent simultanément. Dans ce cas, c’est
celle de priorité complémentaire supérieure qui sera traitée en premier.
La part des bits, qui composent la partie principale respectivement la partie complémentaire des champs de bits
de priorité, peut être spécifiée avec le champ « Interrupt Priority Grouping Bits » (PRIOGROUP) du registre
« Application Interrupt and Reset Control Register » (AIRCR) selon le Tableau 42.
PRIOGROUP Nombre de priorités Nombre de priorités

Point binaire
interrompant non interrompant
0b000 bxxxxxxx.y 128 2

0b001 Bxxxxxx.yy 64 4
0b010 bxxxxx.yyy 32 8
0b011 bxxxx.yyyy 16 16
0b100 bxxx.yyyyy 8 32
0b101 bxx.yyyyyy 4 64
0b110 bx.yyyyyyy 2 128
0b111 b.yyyyyyyy 1 256
Tableau 42 : Les parts interrompant et non interrompant de la priorisation,
source : [Cortex-M4_Devices_GenUserGui]
Avec les processeurs Cortex-M4, toutes les exceptions/interruptions sont traitées dans le mode Handler (voir
chapitre 2.4 : Les modes de fonctionnement et les niveaux de privilège). Ce qui pour avantage que certains
registres ne doivent pas être sauvés car ces derniers sont à double : un registre pour le mode Thread et un autre
registre du même nom pour le mode Handler (banked register).
Exemple :
Le programme principal est interrompu par la requête d’interruption SysTick (priorité principale programmée 3).
Durant le traitement de l’interruption par son traiteur « SysTick_Handler », apparaît une requête
d’interruption SVC (priorité principale programmé 1). Par conséquent, le traiteur SysTick_Handler sera
interrompu au détriment du traiteur « SVCall_Handler ». La Figure 90 montre le comportement temporel de
cet enchaînement d’évènements.

Priorité
SVCall_Handle
SysTick_Handle
Programme
principale Temps
System SVC
Tic
Figure 90 : Emboîtement des interruptions
7.7 Le tableau des vecteurs d’interruption

Lorsqu’apparaît une exception/interruption, la CPU interrompt l’exécution du programme principale afin de
pouvoir traiter cette dernière. Pour cela il va faire un saut à une case mémoire appelée « vecteur d’interruption »,
qui contient soi l’adresse du traiteur d’exception/interruption ou une instruction à exécuter. Chaque
exception/interruption possède son propre vecteur d’interruption. Par conséquent, si un processeur possède N
types d’exception/interruption différents, alors il possèdera également N vecteurs d’interruption. Ces derniers
forment le « tableau des vecteurs d’interruption ».
L’adresse de base du tableau des vecteurs d’interruption est normalement 0. Toutefois, avec les processeurs
Cortex-M4, ce dernier peut être déplacé dans la mémoire. Pour cela il faut spécifier la valeur du déplacement
(TBLOFF) dans le registre de déplacement de la table des vecteurs d’interruption (Vector Table Offset Register :
VTOR). La Figure 91 Illustre l’attribution des bits de ce registre.
Figure 91 : Attribution des bits dans le registre VTOR (Adresse: 0xE000_ED08),

Source [Cortex-M4_Devices_GenUserGui]
Dans certaines familles de processeurs, le tableau des vecteurs d’interruption contient des instructions à exécuter.
Dans ce cas, lorsqu’apparaît une exception/interruption, l’instruction stockée dans le vecteur d’interruption
correspondant est exécutée par la CPU. Cette instruction est en générale un saut de programme avec un offset.
Dans d’autres familles de processeurs, le tableau des vecteurs d’interruption contient les adresses des traiteurs
d’exception (exception Handler). Le processeur charge alors cette adresse afin de réaliser le saut de programme
dans la routine de service correspondant. Les processeurs Cortex-M4 soutiennent cette variante.
Exemple : Tableau des vecteurs d’interruption du Cortex_M4.

g_pfnVectors:
.word _estack
.word Reset_Handler
.word NMI_Handler
.word 0
.word 0
.word 0
.word 0

.word SVC_Handler
.word DebugMon_Handler
.word 0
.word PendSV_Handler
.word SysTick_Handler
/* External Interrupts */
.word WWDG_IRQHandler /* Window WatchDog */
.word PVD_IRQHandler /* PVD through EXTI Line detection */
.word TAMP_STAMP_IRQHandler /* Tamper and TimeStamps through the EXTI line*/
.word RTC_WKUP_IRQHandler /* RTC Wakeup through the EXTI line */
.word FLASH_IRQHandler /* FLASH */
.word RCC_IRQHandler /* RCC */
.word EXTI0_IRQHandler /* EXTI Line0 */
…
Le Tableau des vecteurs d’exception de ci-dessus est construit de manière statique. C'est-à-dire que les adresses
ont été définies de façon fixe pendant la programmation, et sont introduites par le relieur (linker) durant la
procédure de compilation.
Lorsque le tableau des vecteurs d’exception est stocké dans une RAM, il peut être construit de façon dynamique.
Il peut ainsi être initialisé au démarrage du programme et changé durant son déroulement. La procédure est la
suivante :
1) Définition des adresses des traiteurs d’interruption
2) Ecriture de la valeur obtenue dans le tableau des vecteurs d’interrutions avec STR
7.8 Déroulement d’une requête d’interruption

Cette section décrit le déroulement du traitement des exceptions/interruptions avec les processeurs Cortex-M4.
Ce déroulement peut être légèrement avec les autres processeurs.
Entrée :
1) Le traitement de l’exception/interruption n’a lieu que si la requête a suffisamment de priorité et soi
 le processeur se trouve dans un mode Thread ou
 la nouvelle exception/interruption a une priorité plus grande que celle qui est actuellement en
traitement.
Si l’exception/interruption interrompt le traitement d’une autre exception/interruption, cette dernière
sera imbriquée momentanément.
Suffisamment de priorité signifie ici que l’exception/interruption a une priorité plus grande que la limite
fixée dans les registres de masquage de priorité (voir chapitre 2.5.3).
2) Ensuite certain registres sont sauvegardé sur la pile (stack). Cette pile contient entre autre la valeur du
registre du compteur de programme (PC) avant l’apparition de l’exception/interruption. Cette valeur
correspond à l’adresse de l’instruction qui suit celle qui a été interrompue par l’exception/interruption.
A la fin du traitement de l’exception/interruption, cette valeur sera de nouveau réécrite dans le registre
PC, afin de pouvoir réaliser l’opération de retour à partir du traiteur d’exception/interruption. Lorsque la
FPU est active, les registres à virgule flottante seront également sauvegardés sur la pile (voir Figure 96).
3) Durant les opérations de sauvegarde a lieu l’opération d’appel de vecteur. Cette dernière copie l’adresse
de base du traiteur d’exception contenu dans le vecteur d’interruption dans le registre PC. Le pointeur
de pile (MSP ou PSP), le mode de fonctionnement (Thread ou Handler) et le niveau de privilège
(privilégie ou non privilégie) utilisés avant l’apparition de l’exception/interruption sont également écrits
dans le registre LR (EXC_RETURN).

Figure 92 : Structure de la pile (stack) après une exception/interruption
A l’intérieur du traiteur d’exception :

Les traiteurs d’exceptions sont exécutés dans le mode privilégié Handler.
La structure d’un traiteur d’exception est toujours la suivante :
1) Sauvegarde des registres qui sont utilisés en supplément de ceux qui ont été sauvés durant la phase
d’entrée
2) Exécution de la tâche de traitement
3) Restauration des valeurs de registres qui ont été sauvées en supplément au début de la routine
4) Retour
Retour :
Le retour du traiteur d’exception/interruption ne s’effectue que lorsque le processeur se trouve dans le mode
Handler et s’il exécute une des instructions suivantes :
 Une instruction LDM, POP ou LDR qui charge le contenu du registre LR (EXC_RETURN) préalablement
sauvegardé sur la pile dans PC.
 Une instruction BX avec LR
Lorsque le registre PC reçoit la valeur EXC_RETURN, alors il connaît la pile avec laquelle les registres ont été
sauvegardés. Le processeur est ainsi en mesure de démarre la restauration des valeurs des registres sauvegardées
durant la phase d’entrée. Après cette procédure, le registre PC retrouve l’adresse de l’instruction, qu’il contenait
avant l’apparition de l’exception/interruption. Le processeur peut ainsi continuer avec l’exécution du programme
interrompu comme si rien n’était arrivé.
Exemple : Retour depuis le traiteur SysTick_Handler avec BX :

SysTick_Handler:
…
<handler code>
…
BX LR @ PC=LR (return from ISR)

Lorsque le registre LR est utilisé dans le traiteur d’exception, il faut également le sauver sur la pile avec les
instructions STMFD ou PUSH. Dans ce cas, le retour du traiteur peut être programmé avec les instructions
LDMFD ou POP.
Exemple :
SysTick_Handler:
PUSH {R4-R7, LR}
…
BL Scheduler
…
POP {R4-R7, PC} @ PC=LR (return from ISR)
La Figure 93 illustre schématique le déroulement du traitement d’une requête d’exception/interruption.
main:
instr 1
instr 2
Timer Tick
instr3
Exécution des opérations stack
LR = EXC_RETURN PC = EXC_RETURN
Vector Table
Changement dans le mode Handler Retour éventuel dans le mode Thread
MSP sera fixé comme SP MSP ou PSP est fixé comme SP
SysTick_Handler Restauration des valeurs des registres

sauvegardés sur la pile : Retour dans
le programme principale
PC = Adresse du SysTick_Handler
SysTick_Handler:
instr a
instr b
bx lr
Figure 93 : Déroulement du traitement d’une requête d’exception/interruption
Dans l’exemple ci-dessus les instructions 1 et 2 sont exécutées séquentiellement. Ensuite apparaît une
interruption SysTick qui interrompt l’exécution du programme principale (toutefois l’instruction 2 est exécutée
jusqu’au bout). Ensuite la CPU lit l’adresse du traiteur d’exception SysTick_Handler à partir du tableau des
vecteurs d’interruption et exécute ce dernier afin de traiter l’interruption SysTick. Finalement l’état d’origine
est restauré et la CPU continue avec l’exécution des instructions du programme principale.

7.9 Le comportement temporel des interruptions

Le déroulement d’un traitement d’interruption peut être représenté graphiquement de la manière suivante :
Interrupt Request
User Program User Program

CPU context saved
CPU context restored

User ISR Code
Interrupt Latency
Interrupt Recovery
Interrupt Response
Time
Figure 94 : Comportement temporel des interruptions
Le temps de latence d’interruption (Interrupt Latency) est le temps entre l’apparition de la requête d’interruption
(Interrupt Request) et l’exécution de la première instruction du traiteur d’interruption (interrupt handle) :
tILat = tdis + tcmod
tILat : Interrupt Latency

tdis : Temps maximal, pendant lequel l’interruption peut être désactivée
tcmod : Temps nécessaire pour le changement de mode
Le temps de réponse à l’interruption (Interrupt Response) est le temps entre l’apparition de la requête
d’interruption (Interrupt Request) et l’exécution de la première instruction de sa routine de service (ISR) :
tIRes = tIL + tcsw
tIRes : Interrupt Response

tILat : Interrupt Latency
tcsw : Temps nécessaire à la sauvegarde du contexte de la CPU
Le temps de recouvrement de l’interruption (Interrupt Recovery) est le temps nécessaire pour revenir dans le
programme principal après exécution de la routine de service (ISR) :
tIRec = tcsw2 + trti
tIRec : Interrupt Recovery

tcsw2 : Temps nécessaire pour restituer l’ancien contexte
trti : Temps nécessaire pour appeler la routine « return from interrupt »

7.10 Les variantes pour le traitement d’interruptions

Il existe différentes variantes pour implémenter un contrôleur d’interruption : « Nonnested Interrupt Handler »,
« Nested Interrupt Handler », « Reentrant Interrupt Handler », « Prioritized Simple Interrupt Handler » etc.
Toutes ces variantes ont été décrites de façon détaillée dans [10], « ARM System Developer's Guide ». Ce
chapitre ne contient que la description pour le « Nonnested Interrupt Handler ». Ce dernier possède les propriétés
suivantes :
 Traitement des interruptions de façon séquentiel. Le traitement d’une interruption ne peut pas être
interrompu par une interruption de priorité égale.
 Avantage : l’implémentation et les tests sont simples.
 Désavantage : Des temps de latence relativement lents. Ce qui peut être un désavantage pour les
systèmes embarqués avec plusieurs sources d’interruption.
Le « Nonnested Interrupt Handler » fonctionne de la manière suivante :
Interrupt
Disable Interrupts
1 spsr_mode = cpsr
pc = vector table entry
Save context
2
Interrupt Handler
3
Interrupt Service
4
Routine
Restore context
5
Enable Interrupts
6 pc = lr - 4
cpsr = spsr_mode
return
Figure 95 : « Nonnested Interrupt Handler », source: [10]
Le fonctionnement du « Nonnested Interrupt Handlers » est discuté à l’aide de l’exemple IRQ.

1) Le processeur ARM désactive toutes les interruptions IRQ. Ensuite il entre dans le mode IRQ, dans lequel il
sauve et le contenu du registre PSR dans le registre SPSR. Le compteur de programme est finalement chargé
avec l’adresse du vecteur d’interruption (0x00000018).
2) Le contexte doit être sauvegardé : En cas d’appel de fonction C, il faut absolument sauvegarder les registres
r0 à r3 et r12 (voir APCS). Les registre r4 jusqu’à r11 sont sauvés automatiquement par le compilateur
dans les foncions C. S’il n’y a pas d’appel de fonction C, seul les registres affectés doivent être sauvés.
3) Le traiteur d’interruption identifie la source d’interruption et appelle la routine de service adéquate.
4) La routine de service traite l’interruption et désactive l’interruption.
5) Le contexte original est remis.
6) Les interruptions sont de nouveau activées, le registre PSR est remis dans son état initial et le compteur de
programme est chargé avec l’adresse de retour.
Le code en assembleur pour le « Nonnested Interrupt Handler » pourrait être le suivant :

irq_Handler:
SUB lr, lr, #4 @ adjust lr for return address
STMFD sp!, {r0-r3, r12, lr} @ save context
LDR r0, =ICIP @ load IRQ status register address
LDR r0, [r0] @ read IRQ status register
TST r0, #1<<PER_ID_OST @ test if OST caused IRQ
BLNE timer_isr @ if yes, call timer ISR
TST r0, <other source> @ test other IRQ sources
...
LDMFD sp!, {r0-r3, r12, pc}^ @ restore context and return

Informtique 3 Les Structures de contrôle en assembleur
8 Les Structures de contrôle en

assembleur
8.1 Introduction
Le déroulement d’un programme peut être influencé à l’aide de structure de contrôle. Pour cela il existe les
procédures suivantes :
 Les séquences
 Les ramifications
 Les boucles
Une séquence est une suite d’instruction, qui est exécutée sans critères préalables. Alors que les ramifications et
les boucles ne sont exécutées qu’en fonction des critères externes, comme par exemple l’état du processeur.
Les langages de programmation évolués mettent à disposition des instructions standardisées pour définir des
structures de contrôle. Par exemple le langage de programmation C contient les instructions suivantes :
Pour les ramifications :

 if - else (Ramification simple)
 switch (Ramification multiple)
Pour les boucles :

 while (Boucle avec évaluation initiale)
 do - while (Boucle avec évaluation finale)
 for (Boucle d’itération)
Dans le langage de programmation assembleur, il est également possible d’utiliser ces structures de contrôle. Ce
qui permet de mieux structurer le code et, par conséquent, de faciliter son entretient.
Contrairement aux langages de programmations évolués, l’assembleur ne met pas à disposition des instructions
pour la définition des structures de contrôle. Toutefois, ces structures peuvent être réalisées avec des séquences
d’instructions en utilisant des chablons. Les chapitres suivants montrent, comment ces structures de contrôles
peuvent être réalisées en assembleur.

8.2 La ramification simple

Dans la ramification simple, une condition est évaluée au début de l’instruction. Cette condition peut être
« réalisée » (true) ou « non réalisée » (false).
if condition
true false
true- false-
block block
Figure 96 : La ramification simple
Lorsque la condition est réalisée, le programme exécute les instructions qui sont contenues dans le bloc
« then » ; sinon, il exécute les instructions du bloc « else ». Le bloc « else » est en option. C’est à dire
qu’une ramification simple ne peut contenir que du bloc « if ».
Exemple de code :
C Assembler
if if: TST <condition>
(condition)
{ BNE false
/* true-Block */ true: ... @ true-block
} B endif
else
{ false: ... @ false-block
/* false-Block */
} endif:
Tableau 43 : La ramification simple en C et en assembleur, avec un bloc « else »
Une ramification simple sans le bloc « else » peur être programmée de la manière suivante :
C Assembler
if (condition) if: TST <condition>
{ BNE Endif
/* true-Block */ true: ... @ true-block
}
endif:
Tableau 44 : La ramification simple en C et en assembleur, sans le bloc « else »
Une ramification simple contient toujours une instruction d’entrée (ici « TST »), qui modifie les bits d’état le
registre PSR (Current Program Status Register), suivie d’une instruction de saut de programme conditionnel (ici
« BNE »). Toutes les instructions, qui influencent les bits d’état, peuvent être utilisées comme instruction
d’entrée (TST, CMP, MOVS etc.) ; et toutes les instructions « Bcc » peuvent être utilisées comme sauts de
programme conditionnels.
Les architectures ARM soutiennent une autre forme de ramification simple : L’exécution conditionnelle des
instructions. Toutefois cela n’est raisonnable que pour des conditions simples, qui réunissent un à trois

instructions dans un bloc.
Exemple (de [11]):

La recherche du maximum entre deux nombres peut être programmée en C de la manière suivante :
if (a > b)
c = a;
else
c = b;
En assembleur ARM, il est possible de programmer cet algorithme avec des instructions conditionnelles. Ce qui
évite l’utilisation des sauts conditionnels ou inconditionnelles de la structure proposée au Tableau 43 (les
variables a, b et c sont stockées dans les registres r0, r1 et r2) :
CMP r0, r1 @ if (a > b)
ITE GT
MOVGT r2, r0 @ c = a
MOVLE r2, r1 @ c = b
8.3 La ramification multiple

La ramification multiple prend une décision entre plusieurs alternatives. Pour cela une expression d’entrée est
évaluée et le résultat est comparé avec les valeurs constantes de toutes les étiquettes case. En cas de
correspondance, le programme exécute les instructions du bloc appartenant à l’étiquette. S’il n’y a pas de
correspondance, le programme exécute le bloc par défaut.
switch expression
case const-expr1
const-expr1 case const-expr2

block
…
const-expr2
block
default
default
block
Figure 97 : La ramification multiple
Exemple de code :

C Assembler
switch (expression) switch: MOV r0,#expression
{
Case (const-expr1): CMP r0,#const_expr1
... BEQ case1
break;
case (const-expr2): CMP r0,#const_expr2
... BEQ case2
break;
... ...
default: B default
...
break;
}
case1: ... @ const-expr1 block
B endSwitch
case2: ... @ const-expr2 block
B endSwitch
default: ... @ default block
endSwitch:
Tableau 45 : Ramification multiple en C et Assembler
Au début de la ramification multiple, l’expression à évaluer est copiée dans un registre, afin de pouvoir être
comparée avec les constantes des étiquettes case. Lorsqu’il y a correspondance, le programme effectue un saut
à l’étiquette correspondant à la constante, pour y exécuter les instructions.
Le code peut devenir très lent, lorsque l’instruction switch contient de nombreuses étiquettes case. Dans ce
cas, il est recommandé d’utiliser des Tableaux de sauts (jump table). Ces derniers peuvent être programmés de la
manière suivante :
switch: ADR r1, jumptable @ load r1 with base address of jump table
MOV r0, #expression @ load r0 with expression to test
CMP r0, #tablemax @ check if value is in jump table
IT LO
LDRLO pc, [r1, r0, LSL #2] @ ok  load pc with label form jump table
B default @ expression > tablemax  default
case1: … @ const-expr1 block
B endswitch
case2: … @ const-expr2 block
B endswitch
default:
… @ default block
endswitch:
…
jumptable:
.word default @ case 0 not defined  default
.word case1
.word case2
.set tablemax, 0x03 @ jump table has 4 entries
Les limitations des Tableaux de sauts sont les suivantes :

 Le Tableau ne devrait pas être trop grand. Elle ne peut pas contenir toutes les valeurs des expressions

constantes (entier de 32 bits). Un Tableau de saut n’est pas adéquat pour évaluer les expressions de 1 à
10000. Cela nécessiterait un Tableau avec 10000 entrées.
 La taille du Tableau doit être testée durant l’exécution du programme (CMP r0,#tablemax)
 Il faut introduire dans le Tableau le label par défaut pour les valeurs non définies (l’exemple de ci-
dessus ne contient pas le cas 0. Il faut donc introduire une valeur par défaut à l’index 0 du Tableau).
8.4 La boucle avec évaluation de la condition au

début
La boucle avec une évaluation de la condition initiale (boucle while) exécute un bloc de code un certain
nombre de fois, qui n’est pas connu d’avance.
La condition est évaluée au début de la boucle. Si cette dernière est « vraie », le programme exécute les
instructions du corps de la boucle et réitère l’évaluation de la condition. Si cette dernière est « fausse », le
programme quitte la boucle et continue avec les instructions suivantes.
Avec ce genre de boucle, lorsque la condition est « fausse » depuis le début, les instructions de la boucle ne sont
jamais exécutées.
Condition de la boucle
Corps de la
boucle
Figure 98 : La boucle avec une évaluation de la condition au début
Exemple de code :
C Assembler
while (condition) while: TST <condition>
{ BEQ endwhile
// Corps de la boucle … @ Corps de la boucle
} B while
endwhile:
Tableau 46 : La boucle avec une évaluation de la condition au début en C et en Assembler
Les bits d’état courant du programme sont modifiés en fonction de l’instruction d’entrée (comme ce fut le cas
avec la ramification simple). Lorsque la condition « n’est pas réalisée », le programme effectue ensuite un saut
de programme conditionnel à la fin de la boucle. Après exécution des instructions du corps de la boucle, le
programme fait un saut de programme non conditionnel au début de la boucle, afin de réitérer l’évaluation de la
condition.
Le code du Tableau 46 n’est pas très efficace, car il nécessite deux sauts de programme (B et BEQ), qui doivent
être exécutés à chaque passage. Ce code peut être optimisé avec une réorganisation. Dans ce cas, un seul saut de
programme conditionnel (BNE) ne doit être exécuté par passage.
while: B test
loop: … @ Schleifenkörper
test: TST <condition>
BNE loop
endwhile:

8.5 La boucle avec évaluation de la condition à la fin

La condition de la boucle est évaluée ici à la fin de la boucle (contrairement à la boucle avec évaluation de la
condition initiale). Lorsque la condition est « vraie », le programme exécute de nouveau les instructions du corps
de la boucle. Si la condition « n’est pas réalisée », le programme quitte la boucle et continu avec l’instruction
suivante. Avec ce genre de boucle, les instructions du corps de la boucle seront toujours réalisées au moins une
fois.
Corps de la
boucle
Condition de la boucle
Figure 99 : La boucle avec évaluation de la condition à la fin
Exemple de code :
C Assembler
do do:
{
// Corps de la boucle … @ Corps de la boucle
} while (condition); while: TST <condition>
BNE do
enddowhile:
Tableau 47 : La boucle avec évaluation de la condition à la fin en C et en assembler
Les bits d’état sont également modifiés dans cet exemple en fonction de l’instruction d’évaluation (ici « TST »).
Lorsque la condition est « vraie », le programme effectue un saut de programme conditionnel au début de la
boucle. La boucle do - while correspond ainsi à la version optimisée de la boucle while, introduite au
chapitre 8.4, sans la première instruction de branchement.
8.6 La boucle itérative

La boucle itérative (boucle for) est un cas spécial de la boucle avec évaluation de la condition initiale. Dans le
langage de programmation C, toutes les instructions de contrôle sont mises en évidence au début de la boucle.
Normalement ce genre de boucle utilise une variable compteur, qui est initialisée tout au début (valeur départ).
La condition d’arrêt de la boucle est réalisée avec la comparaison de cette variable avec une valeur finale. Tant
que la condition est vraie, le programme exécute le corps de la boucle et incrémente le compteur. Les pas de ce
compteur peuvent être positifs ou négatif.
for (valeur départ, valeur fin, Pas)
Corps de la
boucle
Figure 100 : La boucle itérative

Exemple de code :
C Assembler
for (expr1; expr2; expr3) for: MOV r0,#valeur_début
{ loop: CMP r0,#valeur_fin
// Corps de la boucle BGE endfor
} ... @ Corps de la boucle
ADD r0,r0,#pas
bra loop
endfor:
Tableau 48 : La boucle itérative en C et ne assembleur
Un registre rx (dans cet exemple r0) est utilisé comme variable compteur. Au début cette variable est initialisée
avec la valeur « valeur_début ». A l’étiquette « loop », le critère d’arrêt est évalué à l’aide de l’instruction
CMP, qui teste si la variable compteur a atteint la valeur « valeur_fin ». Si cette dernière atteint cette valeur
limite, le programme fait un saut de programme conditionnel (BGE) à la fin de la boucle. Si non, le programme
exécute les instructions du corps de la boucle et incrémente la variable compteur en fonction de la valeur
« pas ».
Des autres instructions que BGE peuvent également être utilisées pour évaluer la condition d’arrêt. L’instruction
ADD peut être remplacée par SUB afin de réaliser des pas de compteur décroissant.

Informtique 3 Les structures de données en assembleur
9 Les structures de données en

assembleur
9.1 Introduction
Les structures de données rassemblent plusieurs variables (de type simple ou composé) dans une structure. Voici
un exemple de structure de donnée en C :
struct Adresse
{
char Nom [MAX_CHAR];
char Prenom [MAX_CHAR];
char Route [MAX_CHAR];
int Numero;
char Lieu [MAX_CHAR];
};
Les langages de programmation évolués soutiennent les structures de données. Il en résulte les avantages
suivants :
 Compréhension et entretient facilité du programme
 Meilleur structure
En assembleur il est également possible de profiter des avantages des structures de données. Ce chapitre traite ce
sujet.
Les structures de données sont toujours orientées problème. C'est-à-dire, qu’ils essayent de reproduire au mieux
la réalité à l’aide d’un jeu de données (par exemple les données d’un processus). Il existe également une relation
étroite entre ces structures et le code du programme. Par conséquent, la modification d’une structure aura un
effet sur le code.
9.2 Les Tableaux unidimensionnels

Un Tableau (array) contient plusieurs éléments du même type. Ces éléments sont déposés dans la mémoire sans
lacune, l’un derrière l’autre. L’accès à ces éléments s’effectue à l’aide de leur indexe. Le premier élément
possède l’index 0 (array[0])
Exemple : Définition d’un Tableau contenant 4 éléments du type mot :

.data
Array .space 4*4,0x12 @ array of 4 words,
@ each initialized with 0x12121212
La directive « .space » permet de réserver un certain nombre de bytes, qui peuvent être initialisés. Dans cet
exemple 4 * 4 bytes ont été réservés au total et chaque byte a été initialisé avec la valeur 0x12. Si le Tableau ne
doit pas être initialisé, il peut également être défini dans la section « .bss ».
L’élément d’indexe 2 peut être effacé par exemple de la manière suivante :

.text
LDR r0,=array @ load r0 with base address of array
LDR r1,#2 @ load r1 with index 2
MOV r2,#0 @ value to write is 0
STR r2,[r0,r1,LSL #2] @ array[2] = 0

L’adresse de base du Tableau est d’abord copiée dans r0. Ce dernier adresse ainsi le premier élément du
Tableau (indexe 0). L’index de l’élément à accéder est ensuit copier dans r1. L’accès au Tableau est effectué
finalement avec l’instruction STR. L’adressage y est indirect et est obtenu avec « r0 + r1 * 4 ». La
multiplication avec un facteur scalaire (défini dans cet exemple avec LSL #2) est importante, car les adresses
sont toujours calculées en byte.
Important : Un facteur scalaire est utilisé pour l’adressage indirect. Ce dernier possède les valeurs suivantes :
 1 pour les bytes
 2 pour les demi-mots
 4 pour les mots
Le code ci-dessus doit être modifié de la manière suivant avec un Tableau, qui contient des éléments du type
byte au lieu du type mot :
.data
array: .space 4,0x34 @ array of 4 bytes,
@ which are initialized with 0x34
.text
LDR r0,=array @ load r0 with base address of array
LDR r1,#2 @ load r1 with index 2
MOV r2,#0 @ value to write is 0
STRB r2,[r0,r1] @ array[2] = 0 (Byte)
9.3 Les Tableaux multidimensionnels

Soit un Tableau avec 3 lignes et 4 colonnes du type mot (array [3][4]) :
array: .space 3*4*4 @ allocate 3 rows * 4 columns * 4 bytes
Le Tableau peut être représenté de la manière suivante :
[0,0] [0,1] [0,2] [0,3]

[1,0] [1,1] [1,2] [1,3]
[2,0] [2,1] [2,2] [2,3]
Tableau 49 : Tableau à deux dimensions
Les éléments de ce Tableau ne peuvent être stockés soit en ligne ou en colonne. Par exemple, le stockage en
ligne du Tableau, contenant 3 lignes et 4 colonnes, s’effectue de la manière suivante :

[0,0]
[0,1] 1. ligne
[0,2]
[0,3]
[1,0]
[1,1] 2. ligne
[1,2]
[1,3]
[2,0]
[2,1] 3. ligne
[2,2]
[2,3]
Tableau 50 : Stockage en ligne du Tableau
L’accès à l’élément d’indexes de ligne « i » et de colonnes « j » s’effectue de la manière suivante :
Adresse = 4 * i + j
Cette formule n’est valable que pour des Tableaux, qui possèdent une adresse de base nulle et 4 colonnes du type
byte. La formule générale, qui contient également l’adresse de base du Tableau et la taille des éléments, est la
suivante :
Adresse de l’élément = Adresse de base + S * (SZ * i + j)
Les notations de cette formule ont les significations suivantes :

Adresse de base : Adresse de départ du Tableau
S : Facteur scalaire, byte = 1, mot = 2, long mot = 4
SZ : Nombre de colonnes
i : Index de ligne
j : Index de colonne
L’évaluation de cette formule peut s’avérer coûteuse, en fonction de la famille du processeur. Notamment
l’opération de multiplication « SZ * i » peut exiger un temps de calcul important. La multiplication avec le
facteur scalaire S peut, par contre, être effectuée avec des opérations de décalages (facteur 2 ou 4).
9.4 Les chaîne de caractères

Une chaîne de caractères (string) est une suite de caractères ASCII, qui se termine avec le caractère nul ou de fin
de chaîne de caractères (′\0′). La chaîne de caractères est définie de la manière suivante :
text: .asciz "abcABC0123" @ null-terminated string
Remarque : Le caractère nul (′\0 ′) et celui du chiffre zéro (′0′) possèdent des valeurs ASCII différentes.
9.5 Les structures

Les structures de données permettent d’assembler des variables avec des types différents. Par exemple, la
structure pour stocker une date peut par être définie de la manière suivante :

date: .byte 14 @ day as byte (1-31)

.byte 03 @ month as byte (1-12)
.hword 1879 @ year as halfword (e.g. 0000 – 3000)
La structure « date » possède deux membres de type byte et un membre de type demi-mot. L’accès aux
membres de la structure s’effectue à l’aide de déplacements (offset), qui définissent la position relative des
membres dans la structure. Ces derniers sont les suivants pour la structure « date » :
.set OFFSET_MONTH,1
.set OFFSET_YEAR,2
Le membre « day » ne nécessite pas d’offset, car son adresse est identique à celle de base de la structure date.
L’écriture du membre année dans le registre r0 s’effectue par exemple de la manière suivante :
LDR r1,=date @ load r1 with base address

MOV r2,#OFFSET_YEAR @ load r2 with offset
LDRH r0,[r1, r2] @ read year (halfword)
9.6 La pile (stack)

Le chapitre 6 concernant « les sous routines » fournit une description de la structure et du fonctionnement de la
pile. Cette dernière était destinée au transfert des paramètres, à la sauvegarde des registres et la définition des
variables locales. Mais, l’utilisateur peut également définir des autres piles pour la gestion de données.
Directive pour l’implémentation de la pile :

 Les valeurs, qui doivent être déposées sur la pile (push) ou lues à partir de cette dernière (push),
doivent se trouver dans le registre r0. Les opérations de pile peuvent ainsi également être appelées par
les fonctions C. Car selon l’APCS, les paramètres sont transmis ou retournés à l’aide du registre r0.
 La pile de l’exemple est prévue pour les variables du type mots (word).
 La pile croît dans le sens négatif (adresses décroissantes).
 Le pointeur de pile adresse le dernier élément, qui a été déposé sur la pile (push : decrement before,
pop : increment after).
 Le pointeur de pile est une variable globale.
La pile et le pointeur de pile peuvent être définis de la manière suivante :
.set STACK_SIZE,1000 @ define stack size

.data
stack: .space STACK_SIZE,0 @ reserve address space for stack
stackpointer:
.word stack+STACK_SIZE @ global variable,
@ which holds actual stack pointer
Le pointeur de pile doit adresser le début de la pile. Du fait que la pile croît dans le sens négatif, ce début est
l’adresse la plus grande de la pile. Le pointeur de pile est par conséquent initialisé avec « stack +
STACK_SIZE ».
La situation suivante prévaut après l’initialisation :

Pointeur Adresses
de pile hautes
Variable Adresses
pile basses
Figure 101 : La pile après son initialisation
Une opération « push » peut être implémenté de la manière suivante :
@ parameter r0 holds value to write to stack

@ r1 holds stackpointer address
@ r2 holds stackpointer value
@ r3 holds stack address
@ stack full error is not implemented
push: STR lr,[sp,#-4]! @ save return address on system-stack

LDR r1,=stackpointer @ load r1 with stackpointer address
LDR r2,[r1] @ load r2 with stackpointer value
LDR r3,=stack @ load r3 with stack address
CMP r2,r3 @ check if stack is already full
BLE stack_full
SUB r2,#4 @ decrement stackpointer (decrement before)
STR r2,[r1] @ save new stackpointer value
STR r0,[r2] @ push value to stack
B endpush @ go to end
stack_full:
... @ error code
endpush:
LDR pc,[sp],#4 @ return
Une opération « pop » peut être implémentée de la manière suivante :
@ parameter r0 is return value, element read from stack

@ r1 holds stackpointer address
@ r2 holds stackpointer value
@ r3 holds stack address
@ stack empty error is not implemented
pop: STR lr,[sp, #-4]! @ save return address on system-stack

LDR r1,=stackpointer @ load r1 with stackpointer address
LDR r2,[r1] @ load r2 with stackpointer value
LDR r3,=stack @ load r3 with stack address
ADD r3,#STACK_SIZE @ r3 holds stack top address
CMP r2,r3 @ check if stack is empty
BGE stack_empty
LDR r0,[r2] @ pop value from stack, r0 is return value
ADD r2,#4 @ increment stackpointer (increment after)
STR r2, [r1] @ save new stackpointer value
B end pop @ go to end
stack_empty:
... @ error code
endpop:

Contrairement à la pile décrite au chapitre 6, qui ne contient pas de routine de contrôle pour les dépassements de
capacité, il est possible d’ajouter des fonctionnalités de contrôle, afin de pouvoir déceler les éventuels
dépassements.
9.7 Queues et anneaux de tampons (Queue / Ring

buffers)
Contrairement à la pile, une queue de tampons est accessible à ses deux bouts. Son principe est « first in, first
out ». Une queue de tampons fonctionne de la manière suivante :
Put
n. Element Tail / écriture
2. Element
1. Element Head / lecture
Get
Figure 102 : La queue de tampons
Directive pour l’implémentation de la queue de tampons:

 Head et Tail ne doivent se croiser
 La queue de tampons peut engloutir toute la mémoire
Dans la pratique, les queues de tampons sont remplacées par les anneaux de tampons. La problématique de
l’engloutissement de la mémoire est ainsi éliminée. Il existe deux types de réalisation :
a) Head et Tail peuvent adresser le même élément de mémoire. Dans ce cas une variable supplémentaire
« size » est également nécessaire, afin de pouvoir stocker le nombre d’éléments contenus dans l’anneau.
Ainsi, size = 0 correspond à un anneau vide.
Après Apres écriture du

l’initialisation premier élément
Head Tail 1. Element Head

2. Element Tail
size = 0 size = 1
n. Element
Figure 103: Les pointeurs Head et Tail dans une queue de tampons

b) Head et Tail ne peuvent pas adresser le même élément de mémoire. Un élément de mémoire est ainsi
sacrifié, mais la variable supplémentaire size n’est plus nécessaire (size = Tail – Head – 1). La
queue peut ainsi être initialisée avec « Head = 1 » et « Tail = 2 ».
Dans les deux cas il faut systématiquement contrôler les dépassements de capacités des pointeurs Head et
Tail. La Figure suivant illustre un exemple avec un dépassement de capacité de 8 à 1.
Dépassement
Head / Tail /
lecture écriture
1 8
2 7
3 6
4 5
Figure 104 : Anneau de tampons avec 8 éléments

Informtique 3 Le démarrage d’un programme C
10 Le démarrage d’un programme C

Les 3 derniers chapitres de ce manuscrit traitent les projets qui sont définis en C et assembleur.
10.1 Le processus de démarrage d’un programme C

Le processus de démarrage d’un programme désigne la partie du code, qui est exécuté entre de reset et
l’application. Le processus de Démarrage d’un programme en C est illustré schématiquement dans la Figure
suivante. Les différentes tâches de ce processus sont décrites dans les chapitres suivants.
Reset
Bootloader
Code de démarrage du système (CA RM E)
Code de démarrage de l’application
void main (void)

{
// Programme principale
}
Figure 105 : Processus de démarrage
10.2 Le reset
Au début fut le reset. Ce dernier peut être généré par les événements suivants :
 Allumage
 Watchdog
 Touche reset
 Software
Le reset conduit le processeur dans un état défini. Dans la plupart des contrôleurs le reset est le premier vecteur
d’interruption (souvent à l’adresse 0). Ce dernier contient l’adresse de la première fonction, qui doit être appelée
au démarrage du système. Ce qui est normalement le code de démarrage du système (boot loader), lorsque ce
dernier est disponible, ou le code de démarrage de l’application.
10.3 Le code de démarrage du système (boot loader)

Le boot loader est le code, qui initialise le système afin que qu’il puisse fonctionner. Les tâches du boot loader
sont les suivantes :
1. Initialisation des registres les plus importants, en particulier le « Chip-Select », afin que les composants
de la mémoire externe puissent être accédés.
2. Chargement de l’application à partir du flash (ou d’un autre média de stockage non volatil) dans la
mémoire de travail (RAM).
3. Démarrage de l’application.

Remarque 1 : Lorsqu’un système d’exploitation est disponible, le boot loader commence par charger ce dernier.
Ensuite, le système d’exploitation charge les applications.
Remarque 2 : Les processeurs Cortex-M4 permettent de déplace le tableau des vecteurs d’interruption dans la
mémoire. Le registre « Vector Table Offset Register » (VTOR à l’adresse : 0xE000ED08) contient l’adresse de
base de ce tableau.
10.4 Le code de démarrage de l’application

Ce code de démarrage de l’application est exécuté normalement par une ou plusieurs routines assembleur, qui se
trouvent dans un fichier de démarrage. Les noms de ces fichiers dépendent des systèmes de développement.
Toutefois, ces derniers sont souvent appelés « crt0 » ou « startup ».
La programmation du processus de démarrage n’est pas requise avec les programmes en C. En effet, le
compilateur lit automatiquement le code de démarrage à partir d’une librairie et l’insère dans le projet.
L’application C démarre alors avec la fonction principale « main ». Cependant il existe de nombreux cas, où le
code de démarrage doit être modifié. Ce qui exige des connaissances en assembleur.
Le code de démarrage des projets CARME C se trouve dans le fichier « crt0.s », qui se trouve dans le sous
directoire « startup ».
Le code de démarrage doit réaliser les tâches suivantes :

 Définition du Tableau de vecteurs d’interruption de l’application
 Initialisation supplémentaire des registres CPU
 Initialisation de la pile
 Initialisation des variables globale
 Annuler les variables non initialisées
 Initialisation du paquet du support de bord (Board-Support-Package abrégé par BSP)
Définition du Tableau de vecteurs d’interruption de l’application

Le code de démarrage du système (boot loader) exécute en dernier un saut de programme à l’adresse
0x08000000 (flash), où se situe le tableau des vecteurs d’interruption de l’application. Le vecteur
d’interruption reset de ce Tableau contient l’adresse du traiteur « Reset_Handler ». Cette sous-routine
contient le code de démarrage de l’application. Cela est défini de la manière suivante (fichier startup.s) :
.section .isr_vector, "a", %progbits

.type g_pfnVectors, %object
.size g_pfnVectors, .-g_pfnVectors
g_pfnVectors:
.word _estack
.word Reset_Handler
.word NMI_Handler
.word 0
.word 0
.word 0
.word 0
.word SVC_Handler
.word DebugMon_Handler
.word 0
.word PendSV_Handler
.word SysTick_Handler

/* External Interrupts */
.word WWDG_IRQHandler /* Window WatchDog */
.word PVD_IRQHandler /* PVD through EXTI Line detection */
.word TAMP_STAMP_IRQHandler /* Tamper and TimeStamps through EXTI */
.word RTC_WKUP_IRQHandler /* RTC Wakeup through the EXTI line */
.word FLASH_IRQHandler /* FLASH
…
Initialisation supplémentaire des registres CPU

Les registres les plus importants du système sont initialisés par le boot loader. Des registres supplémentaires
peuvent être initialisés à cet endroit, comme par exemple la vitesse de la CPU etc.
Initialisation du le piles
Le code de démarrage de l’application doit également initialiser toutes les piles (stack). En particulier, il doit
initialiser le pointeur de pile principale (MSP) avec l’adresse finale du bloc de mémoire alloué pour la pile
correspondante.
Les blocs de mémoire pour les piles sont réservés dans les fichiers script „stm32f4_flash.ld“
respectivement „stm32f4_ram.ld“.
Exemple :
Un extrait du fichier „stm32f4_flash.ld“:
/* Highest address of the user mode stack */
_estack = 0x20020000; /* end of 128K RAM */
L‘adresse de référence _estack se trouve dans le premier vecteur du tableau des vecteurs d’interruption. Tout
au début du démarrage du système, la valeur de ce dernier est chargée automatiquement dans le registre SP.
Initialisation des variables globale initialisées

Les variables globales peuvent être initialisées en C, exemple:
static int myInt = 5;
Es ce que vous vous être déjà poser la question suivante : comment cette variable est-elle initialisée ? Cette
instruction n’est exécutée par aucune fonction durant tout le déroulement du programme. Cette initialisation est
par conséquent une tâche supplémentaire du code de démarrage, qui est réalisée par un processus appelé « le
traitement ROM » (ROM-Processing).
Le graphique suivant illustre l’initialisation des variables globales :
RAM ROM/Flash
_data
.data
/* variable globale
à initialiser */
static int myInt = 5;
_edata
_etext
Valeur d’initialisation
Figure 106 : L’initialisation des variables globales

Le code de démarrage copie les valeurs d’initialisation des variables globales, depuis le flash dans la RAM. Cela
peut être programmé de la manière suivante :
.section .text.Reset_Handler
.weak Reset_Handler
.type Reset_Handler, %function
Reset_Handler:
/* Copy the data segment initializers from flash to SRAM */
movs r1, #0
b LoopCopyDataInit
CopyDataInit:
Ldr r3, =_sidata
ldr r3, [r3, r1]
str r3, [r0, r1]
adds r1, r1, #4
LoopCopyDataInit:
Ldr r0, =_sdata
Ldr r3, =_edata
adds r2, r0, r1
cmp r2, r3
bcc CopyDataInit
La référence _sidata est l’adresse de base du domaine du flash contenant les valeurs d’initialisation. Les
références _sdata et _edata désignent respectivement le début et la fin du bloc .data contenant les
variables globales à initialiser. _sidata, _sdata et _edata sont définies dans les fichiers scripts
stm32f4_flash.ld respectivement stm32f4_ram.ld.
Exemple : Un extrait du fichier « stm32f4_flash.ld » :

/* used by the startup to initialize data */
_sidata = LOADADDR(.data);
/* Initialized data sections goes into RAM, load LMA copy after code */
.data :
{
. = ALIGN(4);
_sdata = .; /* create a global symbol at data start */
*(.data) /* .data sections */
*(.data*) /* .data* sections */
. = ALIGN(4);
_edata = .; /* define a global symbol at data end */
} >RAM AT> FLASH
Remarque : Lorsque vous travaillez avec le débuggeur, vous chargez le programme dans la RAM à travers son
interface. Dans ce cas, le débuggeur initialise automatiquement les variables globales. Les systèmes, prêts pour
la commercialisation, ne contiennent plus de débuggeur pour réaliser cette initialisation. Dans ce cas, il faut
absolument programmer un code de démarrage.
Mise à zéro des variables non initialisées

Les données non initialisées et la pile sont déposées dans la section .bss. Toutes ces variables sont initialisées
avec 0. Le code est identique à celui pour l’initialisation des variables :
ldr r2, =_sbss
B LoopFillZerobss
/* Zero fill the bss segment. */

FillZerobss:
movs r3, #0
str r3, [r2], #4
LoopFillZerobss:
ldr r3, =_ebss
cmp r2, r3
bcc FillZerobss

Initialisation du paquet de support de la platine

Le paquet de support de la platine (Board-Support-Package abrégé par BSP) initialise les composants hardware
de la périphérie.
10.5 Le programme principale

Les applications simples ne nécessitent pas de systèmes d’exploitation temps réel (Real Time Operating System
abrégé par RTOS). Le programme principal peut alors posséder la structure suivante :
Dans une première étape, il faut initialiser l’application :

 Les composants hardware de la périphérie, à l’aide de leurs registres de configuration
 Les données : les variables, les structures dynamiques etc.
L’initialisation du hardware peut être critique en temps lorsque, par exemple, les sorties du processeur doivent
être rapidement fixés à des niveaux prédéfinis (Exemple : contrôle de moteur). Cette initialisation doit
éventuellement être réalisée dans le code de démarrage ou de façon hardware.
Dans un deuxième temps les fonctions des applications sont appelées de façon cyclique, à l’aide d’une boucle
infinie.
Il en résulte le diagramme de « Nassi-Schneiderman » suivant pour le programme principal :
Initialisation du hardware
Initialisation des données
Boucle infinie
1er Fonction de l’application
2ième Fonction de l’application
...
Nième Fonction de l’application
Figure 107 : Programme principale
Le travail avec les interruptions :

Lorsque vous travaillez avec des interruptions (ISR), il faut faire attention de ne pas perdre trop de temps dans
leurs routines des services. En effet il est fortement recommandé de n’y réaliser que les tâches les plus
importantes, comme par exemple l’activation et la désactivation de drapeaux (flag). Le reste du travail peut ainsi
être effectué à l’aide de machine d’état (state events) en dehors de la routine de service.
Exemple :
Lorsque des bytes sont reçus à l’aide d’une interface sérielle, qui génère des interruptions, il faudrait uniquement
stocker les bytes dans un tampon. Le traitement de ces bytes devrait être réalisé en dehors de la routine de
service.
Un point très important est l’échange de données entre les routines de services et les fonctions de l’application.
Ici la communication n’est possible qu’à l’aide de variables globales (à moins que le système possède un RTOS).

Mais il faut toujours faire attention au fait que les routines de service peuvent sur écrire les données, sans que les
fonctions de l’application principale ne le remarque. Cela est surtout critique avec les données structurées. Par
exemple supposons que le programme possède un tampon de réception de 10 bytes, qui sont remplis par une
routine de service et qui sont lus par les fonctions de l’application principale. Admettons que durant la lecture du
cinquième byte, par une des fonctions de l’application principale, une interruption apparaît pour indiquer la
réception de 10 nouveaux bytes. La routine de service sur écrit alors les 10 bytes du tampon de réception. La
fonction de l’application principale va continuer sa lecture avec le sixième byte, comme si rien ne s’était produit.
Finalement l’application va poursuivre son travaille avec des données inconsistantes. Il faut donc introduire des
mécanismes, qui permettent de verrouiller ces opérations mutuellement. C'est-à-dire qu’aucune interruption de
réception ne devrait être générée pendant que les données sont ne train d’être lues. Le tout peut devenir très
complexe, lorsque plusieurs applications sont exécutées simultanément. Si cette complexité n’est pas maîtrisée
(cela est sûrement le cas, lorsque des nouvelles fonctionnalités, qui n’étaient pas planifiées ont été ajoutée par la
suite), le système va chuter immanquablement.
1er fonction de
l’application
2ième fonction
nième
fonction de l’application
de l’application
3ième fonction ISR

n-1ième
fonction de l’application
de l’application
4ième fonction
de l’application
Variables
globales
Figure 108 : Transfert de données entre les routines de service et les fonctions de l’application
Un RTOS n’est pas nécessaire pour les applications simples. Par contre, un RTOS est recommandé pour les
applications complexes, si les ressources hardware le permettent (CPU, taille de la mémoire etc.). Le module
d’approfondissement « système d’exploitation temps réel » traite ce sujet plus en détail.

Informtique 3 L’interface C et assembleur
11 L’interface C et assembleur
11.1 Introduction
Aujourd’hui la plupart des microcontrôleurs sont programmés à l’aide de langages de programmation évolués,
comme le C et le C++. Toutefois, les parties du code, qui sont critiques soit en temps ou en mémoire, sont
toujours définies en assembleur. Ce qui est particulièrement le cas pour les fonctionnalités suivantes :
 Accès optimal au hardware, spécialement pour les driver
 Les algorithmes, qui exigent une puissance de calcul élevée, afin de pouvoir utiliser la CPU de façon
optimal (unité de multiplication et d’accumulation)
 Les fonctions qui sont souvent traitées, afin d’augmenter la performance du système
 Accès aux registres de la CPU, qui ne sont pas accessibles en C
Dans ce cas une attention particulière doit être apportée sur l’interface C/assembleur. Cette interface dépend
technologiquement de la famille des microcontrôleurs et de leur environnement de développement. Les points
suivants sont à considérer :
 Appel des sous routine assembleur depuis les fonctions C et inversement
 Transmission de paramètres et retour de valeur
 Utilisation de variable C en assembleur et inversement
 Assembleur en ligne
Les mécanismes décrits dans se chapitres se réfèrent au processeur Cortex-M4 ainsi qu’au compilateur GNU
(gcc) et à assembleur de cette famille de processeur.
11.2 Les appels des sous routines assembleur

depuis le C
Les sous-routines en assembleur peuvent être appelées à partir des fonctions C et, inversement, les fonctions C
peuvent être appelées depuis les sous routines en assembleur. Pour cela il faut que les noms soient identiques.
Remarque : Dans certain environnement de développement il faut ajouter un « _ » au début du nom symbolique
assembleur. Cela n’est cependant pas le cas avec les compilateurs GNU.
Exemple pour le code C :

extern int asmsub (int par1, int par2);
int cfunc (int par1, int par2){

return (par1 + par2);
}
void main(void)
{
...
res = asmsub(par1, par2);
...
}
Exemple pour le code assembleur :

.global asmsub @ gives symbol external linkage
.extern cfunc @ specify that cfunc is defined
@ in some other source code file

asmsub: @ assembler subroutine

STR lr,[sp, #-4]! @ save return address on stack
...
BL cfunc @ call C-function
...
11.3 Transmission de paramètres aux sous-routines

assembleur
Le chapitre 8 « les sous routines » traite la transmission des paramètres selon le standard APCS (ARM Procedure
Call Standard). Ce standard doit être respecté si l’on veut programmer en combinant les langages de
programmation C et assembleur.
Ce standard peut être résumé de la manière suivante :

 Les quatre premiers paramètres sont transmis avec les registres r0 à r3, indépendamment du fait que
l’on appelle une fonction C ou une sous routine en assembleur.
 Les paramètres suivants sont transmis à l’aide de la pile.
 Le résultat est retourné avec le registre r0.
11.4 Les registres utilisés par le compilateur

L’APCS spécifie également l’utilisation des registres pour le compilateur. Ces registres doivent donc être utilisés
de la même façon par le programmeur assembleur (voir également le chapitre 8) :
 r13 / sp : pointeur de pile
 r14 / lr : registre du relieur (link register)
 r15 / pc : compteur de programme (program counter)
11.5 L’utilisation de variables en commun

Les variables globales peuvent également être utilisées en commun, dans les parties C et assembleur. Pour cela il
faut faire attention, comme ce fut le cas pour les sous routines et les fonctions, que leurs noms soient identiques
en C comme en assembleur. Ces variables peuvent être définies soit dans la partie C ou dans celle en assembleur.
L’exemple suivant contient une variable globale définie en C (c_var) et une variable globale définie en
assembleur (asm_var) ainsi que les accès sur ces dernières :
Code C :
/* global variables */
int c_var; // reserve memory for word-variable
extern int asm_var; // specified in assembler source
void ctest_var(void){
...
asm_var = 0x22; // modify assembler variable
c_var = 0x55; // modify C variable
}

Code assembleur :
.global asm_var @ give asm_var external linkage
.extern c_var @ specified in C source
...
.data
asm_var:
.space 4,0x11 @ global asm_var,
@ which is initialized with 0x11111111
.text
asmtest_var:
STR lr,[sp, #-4] @ save return address on stack
LDR r0,=c_var @ r0 holds address of variable c_var
MOV r1,#0x55 @ r1 holds value to write to c_var
STR r1,[r0] @ c_var = 0x55
LDR r0,=asm_var @ r0 holds address of variable asm_var
MOV r1,#0x11 @ r1 holds value to write to asm_var
STR r1,[r0] @ asm_var = 0x11
11.6 L’assembleur en ligne

L’assembleur en ligne permet d’insérer des lignes en assembleur directement dans le code C. Il est ainsi possible
d’exécuter les instructions ARM, qui ne sont pas soutenues par le compilateur C. Où le contenu des registres, qui
ne sont pas accessible en C, peut être modifié ; comme par exemple tous les registres de la CPU et du
coprocesseur.
L’utilisation de l’assembleur en ligne peut aider de temps en temps. Toutefois, des effets de bord non souhaités
peuvent apparaître ! Il faut par conséquent faire très attention.
L’instruction (statement) « asm » est mise à disposition par le compilateur GNU gcc pour insérer de
l’assembleur en ligne dans le code C. Cette instruction n’est pas définie par le standard ANSI-C. Par conséquent
cette dernière dépend de l’environnement de développement. Les autres compilateurs utilisent des expressions
comme ASM, __asm ou ASMLINE.
L’utilisation générale de l’instruction asm est la suivante :

asm volatile (code : output operand list : inpup operand list : clobber
list);
Exemple :
asm volatile ("AND %0, %1, #0xFF" : "=r" (result) : "r" (value));
Cette instruction peut paraître un peu compliquée. « volatile » est obligatoire, afin que le compilateur C
n’optimise pas l’instruction asm. L’instruction en soit est composée de quatre colonnes :
1. Le code contient les instructions assembleur, qui ont été définies sous forme de chaîne de caractère :
"AND %0, %1, #0xFF"
2. Output operand list : Les opérandes de sortie, séparées par des virgules, peuvent être définies dans la liste
des opérandes de sortie : "=r" (result). Cette liste des opérandes permet d’accéder également aux
variables C. %0 se réfère au premier élément de la liste. "=r" Signifie que le compilateur peut utiliser un
registre, mais uniquement en mode écriture « write only ».
3. Input operand list : Les opérandes d’entrée, séparées par des virgules, peuvent être définis dans la liste des
opérandes d’entrée : "r" (value). Du fait que ce dernier est le deuxième opérande, %1 permet
d’accéder à la variable value. "r" signifie que le compilateur doit utiliser encore un registre
quelconque.
4. Clobber list : Cette liste informe le compilateur sur les registres, mémoire ou de statut, qui doivent être

modifiés par le code assembleur. La liste clobber est vide dans l’exemple de ci-dessus.
L’exemple le plus simple : Une seule ligne d’assembleur est programmé, sans opérande et sans liste clobber :
asm volatile ("MOV r0, r0"); // NOP (No Operation)
Lorsque plusieurs instructions assembleur peuvent être programmées de la manière suivante :

asm volatile (
"MOV r0, r0" "\n\t"
"MOV r0, r0"
);
"\n\t" permet d’augmenter la lisibilité du code assembleur, qui est généré par le compilateur.
Si une variable C doit être utilisée en tant que paramètre d’entrée, elle peut être définie dans une liste des
opérandes d’entrée. L’exemple suivant ne contient pas de paramètres de sortie, la liste des opérandes de sortie est
ainsi vide. L’exemple illustre également l’accès au registre PSR, ce qui ne serait pas possible en C :
asm volatile("MSR PSR, %0" : : "r" (status)); // load PSR register with
value in status
Le compilateur génère à partir de cette instruction ASM le code objet (désassemblé) suivant :
LDR r3,=status
LDR r3,[r3]
MSR PSR r3
La liste des opérandes d’entrée spécifie l’état "r" pour la variable status. Le compilateur peut ainsi choisir le
un registre quelconque pour exécuter l’instruction. Le registre r3 a été choisi dans l’exemple de ci-dessus.
Il faut informer le compilateur, lorsque l’instruction assembleur change le contenu d’un registre. Le compilateur
ne possède pas les moyens pour remarquer cela. Il dépend donc de cette information, afin qu’il n’y ait pas de
problèmes avec ses propres registres. La déclaration des registres, qui sont modifiés par l’instruction assembleur,
s’effectue dans la liste clobber :
asm volatile("MOV r1, r0" : : : "r1"); // register r1 modified
Finalement encore quelques mots concernant l’exemple du début de ce chapitre :

asm volatile("AND %0, %1, #0xFF" : "=r" (result) : "r" (value));
Ce code possède un paramètre d’entrée, qui est la variable value. value est combiné de façon AND avec la
valeur #0xFF, c'est-à-dire que les 3 bytes de poids plus fort sont effacés. Le résultat de l’opération est déposé
dans la variable result. L’exemple illustre comment l’instruction assembleur peut être étendue et complétée
avec des variables C. Cela n’est par conséquent plus une instruction assembleur pure, mais plutôt un mélange de
C et d’assembleur. Le compilateur génère à partir de cette instruction ASM le code objet (désassemblé) suivant :
LDR r3,=value
LDR r3,[r3]
AND r2,r3,#255
LDR r3,=result
STR r2,[r3]
Du fait que ce code a été généré par le compilateur, il ne faut pas déclarer les registres r2 et r3, qui ont été
modifiées, dans la liste clobber.

Informtique 3 L’adressage des registres en C
12 L’adressage des registres en C

Dans la programmation proche du hardware, il est souvent nécessaire de déposer des variables à des adresses
bien définies (comme par exemple les registres des microcontrôleurs ou des éléments périphériques). Pour cela il
existe les techniques suivantes :
a) Avec #define selon ANSI-C
b) A l’aide de section absolue
c) A l’aide de mots clés spécifiques fournis par le fabriquant
12.1 L’adressage avec #define

Cette variante a été introduite dans le module « Informatique 2 » et est motionné dans ce cours pour des raisons
d’intégrité. C’est la seule méthode pour définir des variables à des adresses fixes, selon le standard ANSI-C.
1) Les variables sont définies de la manière suivante :

// für eine 8-bit Variable auf der Adresse 0x1000
#define reg_8 *((volatile unsigned char *) 0x1000)

#define reg_16 *((volatile unsigned short *) 0x2000)

#define reg_32 *((volatile unsigned long *) 0x3000)
2) L’accès aux variables s’effectue de la manière suivante :

reg_16 = 0x1234;
12.2 La définition de sections absolues

Les environnements de développement permettent de définir des nouvelles sections, qui possèdent leur propre
adresse.
Le compilateur GNU met à disposition le mot clé « __attribute__ », qui permet de spécifier des attributs
pour les variables. Les attributs sont définis entre parenthèses doubles après le mot clé « __attribute__ »,
et la section avec le mot clé « section ».
Exemple : Il faut définir une variable « led », qui permet d’accéder à la ligne de LED sut le kit de
développement CARME. Ces LED sont accessible à l’adresse 0x0C003000.
char led __attribute__ ((section (".LED"))) = 0;

…
led = 0x55;
La première ligne du code C défini une variable led de 8 bits. L’expression

« __attribute__ ((section (".LED"))) » indique que la variable led doit se trouver dans la
section ".LED". L’instruction « led = 0x55; » permet d’afficher un échantillon de bit sur les LED.
La section .LED doit être encore définie dans le script du relieur « stm32f4_flash.ld » respectivement
« stm32f4_ram.ld ». Pour cela deux étapes sont nécessaires.
D’abord il faut spécifier les zones mémoire du kit de développement CARMEIO1 :

Informtique 3 L’adressage des registres en C
/* Specify the memory areas */

MEMORY
{
FLASH(rx) : ORIGIN = 0x08000000, LENGTH = 1024K
RAM(xrw) : ORIGIN = 0x20000000, LENGTH = 128K
MEMORY_B1(rx) : ORIGIN = 0x60000000, LENGTH = 0K
CCMRAM(rw) : ORIGIN = 0x10000000, LENGTH = 64K
CARMEIO1 (rw) : ORIGIN = 0x6C000000, LENGTH = 0x820
}
Ensuite il faut spécifier la section .LED :

.CARMEIO1 :
{
. = ALIGN(4); /* next 32-bit boundary */
_carmeio1 = .; /* defines a symbol for start of CARME IO1 */
*(.LED) /* LED section for CARME IO1 */
. += 0x1FF /* LED address is 0x0C003000 to 0x0C0031FF */
*(.SWITCH) /* Switch section for CARME IO1 */
. += 0x1FF /* Switch address is 0x0C003200 to 0x0C0033FF */
*(.PIO) /* PIO section for CARME IO1 */
. += 0x10 /* PIO address is 0x0C003400 to 0xC003410 */
} >carmeIO1
L’exemple ci-dessus du manuscrit du relieur montre, comment les registres de configuration des différentes
entrées et sorties du kit de développement CARNEIO1 peuvent être rassemblés en sections.
12.3 L’utilisation de mots clés spécifiques du

fabriquant
Certain compilateur mettent à disposition des mots clés spécifiques, pour déposer les variables à des adresses
fixes, comme par exemple « _at_ » ou « _at ».
Exemple :
volatile unsigned short reg1 _at 0x1000;
Le compilateur GNU ne propose pas de tel mot clé.

Informtique 3 Annexe A : Le stockage des nombres
Annexe A : Le stockage des nombres

Les grandeurs suivantes sont mises à disposition pour stocker les nombres :
Bit (1 Bit): Domaine de représentation 0..1

0
Nibble (4 Bit): Domaine de représentation 0...15

3 0
Byte (8 Bit): Domaine de représentation 0..255

7 0
Halfword (16 Bit): Domaine de représentation 0…65535

15 0
Word (32 Bit): Domaine de représentation 0…429496729

31 0
Le bit le plus faible d’un nombre binaire (byte, demi-mot et mot) est qualifié de LSB (Least Significant Bit). Le
bit le plus fort est le MSB (Most Significant Bit).
Un demi-mot est composé de deux bytes : le « lower Byte » (les bits 0 à 7) et le « upper Byte » (les bits 8 à 15).
Un mot est composé de deux demi-mots : « lower Halfword » (bit 0 bis 15) et le « upper Halfword » (bit 16 bis
31).

Informtique 3 Annexe B : Les formats des nombres
Annexe B : Les formats des nombres
Complément à deux
Le complément à deux permet de représenter les nombres négatifs dans le système binaire. Des symboles
supplémentaire comme + et – ne sont ainsi plus nécessaire.
Dans le complément à deux, les nombres positifs sont représentés avec un premier bit 0 (le bit de poids le plus
fort qui est également appelé le bit de signe). Les valeurs négatives sont représentées avec un premier bit 1. Ces
dernières sont codées de la manière suivante : tous les bits du nombre positif sont d’abord inversés et la valeur 1
est ensuite additionnée au résultat.
Exemple :
+4(10) = 00000100
-4(10) = 11111011 + 1 = 11111100
-1(10) = 11111111
127(10) = 01111111
-128(10) = 10000000
Le complément est un système de nombres signés, qui ne possède qu’une seule représentation de la valeur nulle.
Les additions et les soustractions peuvent être ainsi être effectuées sans dissociation de cas. Il n’existe qu’une
seule représentation de la valeur nulle, si l’on admet que les bits, résultants des dépassements de capacité, sont
tronqués durant les opérations.
Par exemple, l’opération :

-4 + 3 = -1
sera calculé de la manière suivante :
11111100 + 00000011 = 11111111;
Nombre à virgule flottante

Les nombres réels sont représentés dans les ordinateurs à l’aide de nombres à virgule flottante (Floating Point)
avec le format IEEE. Le nombre à virgule flottante Z est ainsi représenté avec sa mantisse (M) et sont exposant
(P) par rapport à la base 2.
Il existe plusieurs possibilités pour stocker la mantisse et l’exposant dans la mémoire. Par exemple avec la
précision simple (32 bits) ou double (64 bits). Ce chapitre se concentre uniquement sur le format précision
simple. Ce dernier est stocké dans la mémoire de la manière suivante :
31 30 23 22 0
V E + 127 M
1 bit 8 bits 23 bits
Représentation Description Domaine des nombres

V Bit de signe 0: positif, 1: négatif
E Exposant -126 bis +127
M Mantisse 1,111..111 bis 1,999...999
Tableau 51 : Précision simple de nombres à virgule flottante
Seule la partie fractionnaire de la mantisse est stockée dans la mémoire (hidden bit). Il en résulte la formule
suivante pour la construction des nombres à virgule flottante :
Z = (-1)V M * 2E-127

Informtique 3 Annexe C : Les vecteurs d’interruption
Annexe C : Les vecteurs d’interruption

Informatik 3 Annexe D : La documentation



Annexe D : La documentation
Nom Edition / Auteur Referenz
ARM v7-M Architecture ARM [ARMv7M_ArchRefMan]
Reference Manual
ARM Cortex-M4 Processor ARM [ARM_Cortex-M4_Processor_TechRefMan]
Technical Reference Manual
Cortex-M4 Devices ARM [Cortex-M4_Devices_GenUserGui]
Generic User Guide
STM32F405xx/STM32407xx ST [STM32F407xx_Datasheet]
Datasheet – production data
Samsung Mobile-SDRAM K4S561633 Samsung [Samsung_SDRAM]
The I2C-Bus Specification, V2.1, Jan 2000 Philips [Philips_I2C]
Tableau 52 : Documentation
Titre Edition / Auteur Référence

ARM System Developer’s Guide Sloss / Symes / Wright [Sloss_SysDevGuide]
ISBN: 978-1-55860-874-0 Morgan Kaufman Verlag
ARM System on Chip Architecture Steve Furber [Furber_SoCArch]
ISBN: 0-201-67519-6 Addison Wesley
Tableau 53 : La littérature
Nom Edition / Auteur Référence

GNU Assembler GNU [GNU_Ass]
http://www.gnu.org/software/binutils/manual/gas-
2.9.1/html_mono/as.html
GNU Compiler GNU [GNU_Comp]
http://gcc.gnu.org/onlinedocs/
Tableau 54 : Les liens Internet

Informtique 3 Annexe E : Le jeu d’instructions Thumb
Annexe E : Le jeu d’instructions Thumb

Thumb state is an added advantage in ARM to reduce the code size. In fact, ARM has single instruction set.
Thumb is short hand 16-bit representation of a subset of those instructions. The processor fetches these 16-bit
instructions and expands into 32-bit equivalent. So, ARM and Thumb differs only in how the instructions are
fetched and interpreted, not in execution. So, speed is not at all changed. CPU has dedicated hardware within the
chip to interpret the Thumb instructions.
ARM (Advanced RISC Machines) Thumb ("T" in the core's full name specifies
Thumb. E.g.: ARM7TDMI)
Needs more memory than Thumb, since all are RISC Reduced memory consumption with 16-bit
32-bit instructions instructions (have some 32-bit instructions too)
Totally 18 Registers: R1-R12, SP(R13), LR(R14), Totally 12 Registers: R1-R7, SP, LR, PC, PSR (These
PC(R15), PSR used in exceptions 12 registers have to be used to pass data between
ARM and Thumb state)
T bit = 0 of PSR represents ARM state Totally 12 Registers: R1-R7, SP, LR, PC, CPSR
(These 12 registers have to be used to pass data
between ARM and Thumb state)
Branch instruction (BX or BLX) to the address with Branch instruction (BX or BLX) to the address with
LSB set to 0 enters ARM state. (E.g.: BX 0x80000000 LSB set to 1 enters Thumb state. (E.g.: BX
0x80000001)
When exception occurs, ARM state is entered. -
When return from Exception, if T bit of PSR is set to When return from Exception, if T bit of SPSR is set to
0, returns to ARM 1, returns to Thumb
- No way (instruction) to access status or coprocessor
registers
Load and store instructions of R13 register Has stack mnemonics PUSH, POP
manipulates stack
- Advantages: Reduced memory, 16-bit bus can be used
without compromising with speed.
Disadvantages: As above said, No way (instruction) to

access status or coprocessor registers. Some functions
that can be accomplished in a single ARM instruction
can only be simulated with a sequence of Thumb
instructions.
Tableau 55 : Differences between ARM and Thumb Instruction sets

Informatik 3 Anhang C: ELWMS332
Annexe D : Tableau des valeurs ASCII

Caract. Valeur Hex. Caract. Valeur Hex. Caract. Valeur Hex. Caract. Valeur Hex.
NUL 0 0x00 SOH 1 0x01 STX 2 0x02 ETX 3 0x03
EOT 4 0x04 ENQ 5 0x05 ACK 6 0x06 BEL 7 0x07
BS 8 0x08 TAB 9 0x09 LF 10 0x0A VT 11 0x0B
FF 12 0x0C CR 13 0x0D SO 14 0x0E SI 15 0x0F
DLE 16 0x10 DC1 17 0x11 DC2 18 0x12 DC3 19 0x13
DC4 20 0x14 NAK 21 0x15 SYN 22 0x16 ETB 23 0x17
CAN 24 0x18 EM 25 0x19 SUB 26 0x1A ESC 27 0x1B
FS 28 0x1C GS 29 0x1D RS 30 0x1E US 31 0x1F
Leerz. 32 0x20 ! 33 0x21 " 34 0x22 # 35 0x23
$ 36 0x24 % 37 0x25 & 38 0x26 ' 39 0x27
( 40 0x28 ) 41 0x29 * 42 0x2A + 43 0x2B
, 44 0x2C - 45 0x2D . 46 0x2E / 47 0x2F
0 48 0x30 1 49 0x31 2 50 0x32 3 51 0x33
4 52 0x34 5 53 0x35 6 54 0x36 7 55 0x37
8 56 0x38 9 57 0x39 : 58 0x3A ; 59 0x3B
< 60 0x3C = 61 0x3D > 62 0x3E ? 63 0x3F
@ 64 0x40 A 65 0x41 B 66 0x42 C 67 0x43
D 68 0x44 E 69 0x45 F 70 0x46 G 71 0x47
H 72 0x48 I 73 0x49 J 74 0x4A K 75 0x4B
L 76 0x4C M 77 0x4D N 78 0x4E O 79 0x4F
P 80 0x50 Q 81 0x51 R 82 0x52 S 83 0x53
T 84 0x54 U 85 0x55 V 86 0x56 W 87 0x57
X 88 0x58 Y 89 0x59 Z 90 0x5A [ 91 0x5B
\ 92 0x5C ] 93 0x5D ^ 94 0x5E _ 95 0x5F
` 96 0x60 a 97 0x61 b 98 0x62 c 99 0x63
d 100 0x64 e 101 0x65 f 102 0x66 g 103 0x67
h 104 0x68 i 105 0x69 j 106 0x6A k 107 0x6B
l 108 0x6C m 109 0x6D n 110 0x6E o 111 0x6F
p 112 0x70 q 113 0x71 r 114 0x72 s 115 0x73
t 116 0x74 u 117 0x75 v 118 0x76 w 119 0x77
x 120 0x78 y 121 0x79 z 122 0x7A { 123 0x7B
| 124 0x7C } 125 0x7D ~ 126 0x7E DEL 127 0x7F
Tableau 56 : Tableau des valeurs ASCII

Informtique 3 Index
Index
boucle while ................... 135
. 8
break point ........................... 87
.2byte ............................... 94 8051 ...................................... 28 BSP .................................... 149
.4byte ............................... 94 bus d’adresse ......................... 6
A
.align ............................... 91 bus de contrôle....................... 6
.arm .................................... 90 Ablauf einer bus de données....................... 6
.ascii ............................... 93 Interruptanforderung ...... 127 BX ........................................ 83
.asciz ............................... 93 Acknowledge bit .................. 24 byte .............................. 45, 157
.asm .................................... 58 ADC ................................ 77, 78
C
.balign ............................. 92 ADD ................................ 77, 78
ADR .................................... 103 call by reference ................ 112
.bin .................................... 59
adressage des registres ....... 155 call by value....................... 112
.bss .................................... 96
adresse de retour ................. 108 callee .................................. 107
.byte ................................. 93 caller .................................. 107
adresse physique................... 14
.data ................................. 96 caractéristiques AC .............. 12
adresse virtuelle .................... 14
.elf .................................... 59 ALU ................................. 5, 35 caractéristiques DC .............. 12
.else ............................... 101 amplificateur de sortie .......... 18 carry ..................................... 42
.end .................................. 100 AND ................................ 77, 80 case mémoire ....................... 10
.endif ............................. 101 anneau de tampons ............. 143 cercle de nombre.................. 43
.endm ............................... 103 APCS .......... 109, 112, 114, 152 chaîne de caractère ............ 140
.equ .................................... 95 architecture ............................. 3 champ des étiquettes ............ 52
.extern ............................. 90 architecture ARM ................. 30 chip select .............................. 8
.global ............................. 90 architecture de Harvard .......... 4 choix parmi une liste............ 63
.hword ............................... 94 architecture de stockage ....... 10 CISC .................................... 27
.if .................................... 101 architecture de Von Neumann 3 clobber list ......................... 153
argument ............................. 115 CLZ ...................................... 87
.ifndef ........................... 102
arithmétique des entiers ........ 77 CMN ................................ 77, 78
.include .......................... 95
ARM..................................... 30 CMP ................................ 77, 78
.irp .................................. 105
array ................................... 138 code d’opération .................. 63
.lis .................................... 58
ascending ............................ 109 code de condition ................. 64
.macro ............................. 103
asm .................................... 153 code de démarrage ............. 146
.map .................................... 59 code machine ................. 50, 58
ASR ................................ 68, 81
.o......................................... 58 assemblage conditionnel..... 101 code récursif ...................... 108
.org .................................... 96 assembleur ............................ 58 cœur ..................................... 35
.p2align .......................... 92 assembleur en ligne ............ 153 ColdFire ............................... 28
.rept ............................... 104 assignation des pins .............. 12 commentaire ........................ 54
.s......................................... 58 compilateur .......................... 58
.section .................. 96, 155 B complément à deux .............. 56
.section absolue .................. 155 B 83 complément à un.................. 56
.set .................................... 95 Barrel Shifter .................. 35, 67 compteur de programme . 5, 41,
.space ............................... 94 baud rate ............................... 20 115
.text ................................. 96 BIC ................................ 77, 80 condition .............................. 80
.thumb ............................... 90 big endian ............................. 45 condition d’arrêt .................. 24
.word ................................. 94 binaire................................... 56 condition de démarrage ....... 24
bit ....................................... 157 Condition Flags ................... 42
_ bit C ...................................... 42 Conditional Execution ......... 42
bit d’état ......................... 41, 42 constante ........................ 54, 64
__attribute__ ............ 155
bit N...................................... 42 contexte ............................. 129
_at .................................... 156 control bus ............................. 6
_at_ .................................. 156 bit V...................................... 42
bit Z ...................................... 42 convertisseur A/D ................ 26
= BKPT .................................... 87 convertisseur D/A ................ 27
BL ................................. 83, 108 core ...................................... 35
= 95 Cortex M4............................ 33
BLX ...................................... 83
1 Counter ................................ 25
boot loader .......................... 145
CPSR ................................... 41
1 of X Decoder ....................... 8 boucle ................................. 131
CPU ....................................... 4
boucle d’itération................ 131
6 CPU32 ................................. 28
boucle do while ............. 136
Cross Assembleur ................ 58
68HCxx ................................ 28 boucle for ......................... 136
crt0 ................................. 146

Informtique 3 Index
CS........................................... 8 G Linkmap............................. 100

linkscript .............................. 99
D gestion de projet ................... 59
list file .................................. 58
GPIO .................................... 38
Data Abort.......................... 118 listing de l’assembleur ......... 58
débuggeur............................. 59 H little endian .......................... 45
Decode ................................... 5 localisateur........................... 59
halfword ....................... 45, 157
décodeur d’adresse ................. 8 Locator................................. 59
Header .................................. 52 logique ................................. 56
descending.......................... 109
hexa décimal......................... 93 lower byte .......................... 157
directive de l’assembleur ..... 89
hiérarchie des composants de
directive de programmation . 51 LSL ................................ 68, 81
stockage ............................ 13
disabled .............................. 121 LSR ................................ 68, 81
dispositif de commande ......... 5 I
DMA .............................. 17, 38 M
I2C ........................................ 23
do while ........................ 136 macro instruction ............... 103
IDE ....................................... 56
documentation ...................... 12 main ................................. 146
if ....................................... 132
DRAM ................................. 10 manipulation des bits ........... 80
DSP .................................. 4, 27 indexation ............................. 63
initialisation des variables .. 147 MC683xx ............................. 28
E input operand list ................ 153 MCR ...................................... 66
instruction ......................... 1, 52 mémoire cache ..................... 13
éditeur .................................. 57 mémoire de masse ............... 14
instruction ARM ................... 63
EEPROM ............................... 9 mémoire de travail ............... 13
instruction conditionnelle ..... 64
empty ................................. 109 mémoire des données............. 3
instruction d’état ................... 75
entrée et sortie digitale ......... 19 mémoire non volatile ............. 9
instruction de décalage ......... 81
environnement de mémoire programme.............. 3
instruction de transport entres
développement ................. 56 mémoire volatile .................. 10
registres ............................ 67
EOR ................................ 77, 80 memory map .................... 7, 46
instruction IT ....................... 86
EPROM .................................. 9 memory matrix .................... 10
instruction logique ................ 80
équation logique ..................... 8 Memory Protection Unit ...... 34
instruction non définie ........ 118
ET......................................... 80 microcontrôleur ................... 27
instruction pour la pile.......... 74
état du processeur ................. 41 microprocesseur ................... 27
Instruction Unit ...................... 5
évènement .......................... 118 MIMD .................................... 2
instructions de transfert de
exception ............................ 118 MIPS.................................... 28
données............................. 66
Exception Handler...... 118, 126 MISD ..................................... 2
interface C/assembleur ....... 151
Execute................................... 5 MISO ................................... 22
interface du bus ...................... 5
exécution conditionnelle ...... 42 MLA ................................ 77, 78
interface sériel ...................... 20
External interrupt/event MMU ................................... 14
Interrupt Mask ...................... 41
controller .......................... 38 mnemonics........................... 52
Interrupt Service Routine ... 118
EXTI .................................... 38 mode d’adressage ................ 70
interruption ......... 118, 119, 149
F interruption hardware ......... 119 mode de fonctionnement ..... 39
interruption software ... 87, 118, modèle de stockage.............. 45
famille de microcontrôleur ... 27 modulo ................................. 56
119
famille de processeur ARM . 31 MOSI ................................... 22
IRQ ..................................... 118
FeRAM ................................ 10 mot clé ............................... 156
ISR ............................. 118, 149
Fetch....................................... 5 MOV ................................ 66, 67
fichier assembleur ................ 51 J MRAM ................................ 10
fichier de mappage ............... 59 MRC ...................................... 66
jeu d’instruction.............. 52, 61
fichier elf .............................. 59 MRS ................................ 66, 75
JTAG .................................... 34
fichier objet .......................... 58 MSP430 ............................... 28
jump table ........................... 134
FIQ ..................................... 118 MSR ................................ 66, 75
FLASH ................................. 10 L MUL ................................ 77, 78
Flexible Static Memory
langage de programmation MVN ................................ 66, 67
Controller........................ 38
évolué ....................... 50, 151
Floating-Point Unit .............. 34 N
FLOPS ................................. 28 last in, first out.................... 109
for .................................... 137 LDC ...................................... 66 negative ............................... 42
LDM ................................ 66, 73 Nested vectored interrupt
FPU ........................................ 5
LDR ................................ 66, 69 controller ......................... 38
frame pointer .............. 116, 152
LDR B ............................... 69 Nested Vectored Interrupt
frames................................... 15
LDR H ............................... 69 Controller......................... 34
FSMC ................................... 38
LDR SB ............................. 69 nibble ................................. 157
full ...................................... 109
LDR SH ............................. 69 nom de registre .................... 63
Nonnested Interrupt Handler
Link Register ........................ 40
....................................... 129
Linker ................................... 59

Informtique 3 Index
NOT ...................................... 80 Real Time Clock................... 38 structure ............................. 140

nul ...................................... 140 registre ........................ 5, 13, 39 structure de contrôle .......... 131
NVIC .............................. 34, 38 registre de reliage ....... 108, 115 structure de données .......... 138
registre scratch.................... 115 structure de répétition ........ 104
O relieur ................................... 59 SUB ................................ 77, 78
open drain............................. 19 reset ............................ 118, 145 SWI...................................... 87
opérande ......................... 35, 53 ressource hardware ............. 150 switch............................. 134
opérateur .............................. 55 retour de sous routine ......... 108 SWP ................................ 66, 72
opérateur assembleur.......... 101 RISC ............................... 27, 30 SWPB ................................... 72
opération .............................. 52 ROM....................................... 9 symbole ............................... 54
opération de décalage ..... 64, 68 ROM-Processing ................ 147 syntaxe ................................. 63
opération pop ..................... 142 ROR ................................ 68, 81 syntaxe de l'assembleur ....... 52
opération push .................... 142 rotate..................................... 81 System Timer....................... 34
organisation de la mémoire .. 12 RRX ................................ 68, 81 système d’exploitation temps
ORR ................................ 77, 80 RS232 ................................... 20 réel ................................. 150
OTP ........................................ 9 RSB ................................ 77, 78 système de bus ....................... 6
OU........................................ 80 RSC ................................ 77, 78 système faiblement couplé..... 2
output operand list .............. 153 RTC ...................................... 38 système fortement couplé ...... 2
overflow ............................... 42 RTOS ................................. 149
T
P S
table de vérité ...................... 12
pages .................................... 15 saut de programme ............... 83 Tableau .............................. 138
paramètre............................ 113 saut de programme absolu .... 82 Tableau de page ................... 15
périphérie ............................. 18 saut de programme Tableau de saut .................. 134
PIC ....................................... 28 conditionnel ...................... 82 Tableau des vecteurs
pile ............................. 108, 141 saut de programme d’exception .................... 124
pipeline................................. 36 inconditionnel ................... 82 Tableau multidimensionnel 139
plan de mémoire ............... 7, 46 saut de programme relatif ..... 82 taille de la mémoire ............. 12
point d’arrêt.......................... 87 sauvegarde des registres ..... 112 TDMI ................................... 31
pointeur de pile ... 40, 109, 115, SBC ...................................... 78 tension du bus ........................ 7
152 SDRAM................................ 10 TEQ ...................................... 78
pointeur de trame ............... 152 séquence d’instructions ...... 131 Timer ............................. 25, 38
pop ..................................... 109 set de registre........................ 39 TLB ..................................... 16
portable ................................ 50 shift....................................... 81 totem pole ............................ 19
post indexation ..................... 70 Sign Extend .......................... 45 traitement d’exception ....... 118
Power-Management ........... 38 signal PWM .......................... 25 transfert des paramètres ..... 112
pré indexation....................... 70 signé ..................................... 56 transmission des paramètres
Prefetch Abort .................... 118 SIMD ...................................... 1 ................................114, 152
principe des contributions .. 112 SISD ....................................... 1 tri state ................................. 19
priorité des interruptions .... 122 SMLA .............................. 77, 78 TST ...................................... 78
priorité des opérateurs .......... 56 SMLAL ............................ 77, 78
processus de démarrage ..... 145 U
SMLAW ............................ 77, 78
Program Counter ............ 5, 152 SMUL .............................. 77, 78 UMLAL ................................. 78
programme principale ........ 149 UMLULL............................... 77
SMULL .................................. 78
pseudo code.......................... 50
SMULW ............................ 77, 78 UMULL ................................. 78
pseudo instruction ................ 89
source d’erreurs .................. 116 unité de calcul ........................ 5
push .................................... 109
sous programme ................. 107 unité de contrôle .................... 5
Q sous routine ........................ 107 upper byte .......................... 157
SPI ........................................ 21 V
QADD .............................. 77, 78
SRAM .................................. 10
QADDD ................................. 77 v5TE .................................... 32
stack ........................... 108, 141
QDADD ................................. 78 stack pointer ......... 40, 109, 152 variable globale ................. 152
QDSUB ................................. 78 startup ........................... 146 variable locale.................... 115
QDSUM ................................. 77 startup code ........................ 146 variable registre ................. 115
QSUB .............................. 77, 78 STC ...................................... 66 vecteur d’exception ........... 124
queue de tampons ............... 143 STM ................................ 66, 73 vue d’ensemble des
STR ................................ 66, 69 instructions ...................... 66
R
STRB .................................... 69 W
RAM .................................... 10
STRD .................................... 69
ramification ........................ 131 while ............................... 135
STRH .................................... 69
ramification multiple .......... 133 word ............................. 45, 157
ramification simple ............ 132 string................................... 140

Informtique 3 Index
X Z
XOR ...................................... 80 zero ....................................... 42
zone mémoire ......................... 3

Langue

3 La Programmation en Assembleur 3.1 Introduction (PDFDrive)

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

3 La Programmation en Assembleur 3.1 Introduction (PDFDrive)

Titre original :

Transféré par

Droits d'auteur :

Formats disponibles

Informatique 3

 2008 HESB-TI / Dr E. FIROUZI

Dernier changement : Août 2015

Des informations supplémentaires sont mises à disposition sur le site: http://prof.hti.bfh.ch/fue1

A la fin de ce module, les étudiants sont en mesure de :

Bienne, août 2015

Version 3.1, juin 2008 Page I

Table des matières

Version 3.1, juin 2008 Page II

2.5.3 Exception Mask Registers ............................................................................................................. 43

Version 3.1, juin 2008 Page III

5.1 Introduction ........................................................................................................................................... 90

Version 3.1, juin 2008 Page IV

8.2 La ramification simple ........................................................................................................................ 134

Version 3.1, juin 2008 Page V

1 Architecture d’un microordinateur standard

1.1 Les catégories des ordinateurs

Tableau 1 : Les catégories des ordinateurs

Version 3.1, juin 2008 Page 1

1.1.2 La communication chez les ordinateurs MIMD

a) Les systèmes fortement couplés (shared memory)

b) Les systèmes faiblement couplés (distributed memory)

Figure 2 : Les systèmes faiblement couplés

Comparaison entre les systèmes fortement et faiblement couplés :

c) Combinaison de systèmes fortement et faiblement couplés :

Version 3.1, juin 2008 Page 2

couplés. Cela découle des avantages et des désavantages de ces systèmes.

Mémoire CPU CPU Mémoire CPU CPU

Mémoire CPU CPU Mémoire CPU CPU

Figure 3 : Combinaison de systèmes fortement et faiblement couplés

1.2 Les architectures des microordinateurs

1.2.1 L’architecture de Von Neumann

Figure 4 : Architecture de Von Neumann

Version 3.1, juin 2008 Page 3

1.2.2 L’Architecture de Harvard

Figure 5 : L’architecture de Harvard

Bus de contrôle Bus d’adresse Bus des données

Unité de contrôle Unité de calcul

Figure 6 : Structure de la CPU

Version 3.1, juin 2008 Page 4

Les tâches de l’unité de contrôle sont les suivantes :

1.4 Le système de bus

Version 3.1, juin 2008 Page 5

Figure 7: Bus d’adresse, de données et de contrôle

int temp = Temperatur_Sensor_x;

Version 3.1, juin 2008 Page 6

Bus AMP APE AMD

Bus de DMP DPE DMD

1) 2) 3) 4) 5) 6) 7) 8) 9) 10) 11) 12)

Figure 8 : Le timing du bus

Les abréviations suivantes ont été utilisées dans la Figure précédente :

De plus les notations suivantes illustrent l’état de la tension du bus :

La tension du bus n’est pas valable ("don't care")

La tension du bus change

1.4.2 Le plan de mémoire

Version 3.1, juin 2008 Page 7

Adresse A15 A14 A13 A12

Figure 9 : Exemple d’un plan de mémoire avec un bus d’adresse de 16 bits

1.4.3 Le décodeur d’adresse

Figure 10: Décodeur d’adresse programmable

Version 3.1, juin 2008 Page 8