Sujets T DTP

Université Grenoble Alpes (UGA)
UFR en Informatique, Mathématique et Mathématiques Appliquées (IM2AG)

Département Licence Sciences et Technologies (DLST)
Unité d’Enseignement INF401 aux Parcours INF et MIN :
Introduction aux Architectures

Logicielles et Matérielles
Documentation Technique
Sujets des Travaux Dirigés
Sujets des Travaux Pratiques
Année Universitaire 2017 / 2018
Equipe
c d’Enseignement INF401 ALM de l’UJF - 11 décembre 2017 1
Table des matières
I Documentation Technique 4
1 Environnement informatique pour les travaux pratiques 5
2 Langage machine et langage d’assemblage ARM 9
II Travaux Dirigés 23
1 TD séance 1 : Codage 24
2 TD séance 2 : Représentation des nombres 26
3 TD séance 3 : Langage machine, codage des données 36
4 TD séance 4 : Codage des données (suite) 40
5 TD séances 5 et 6 : Codage des structures de contrôle 44
6 TD séance 7 : Fonctions : paramètres et résultat 48
7 TD séance 8 : Appels/retours de procédures, action sur la pile 54
8 TD séance 9 : Correction partiel 57
9 TD séance 10 : Paramètres dans la pile, paramètres passés par l’adresse 58
10 TD séance 11 : Etude du code produit par le compilateur arm-eabi-gcc, optimisa-

tions 60
11 TD séance 12 : Organisation d’un processeur : une machine à pile 70
III Travaux Pratiques 76
1 TP séance 1 : Représentation des informations (ex. : images, programmes, entiers) 77
2 TP séance 2 : Codage et calculs en base 2 83
3 TP séances 3 et 4 : Codage des données 86
4 TP séance 5 : Codage de structures de contrôle et le metteur au point gdb 92
5 TP séances 6 et 7 : Parcours de tableaux 96
Equipe
6 TP séances 8, 9 et 10 : Procédures, fonctions et paramètres 101
7 TP séance 11 : Etude du code produit par le compilateur arm-eabi-gcc, optimisa-

tions 108
8 TP séances 12 : Procédures et paramètres 111
IV Annexes 121
1 Annexe I : Codage ASCII des caractères 122
2 Annexe II : Entiers en base 2, types C 123
3 Annexe III : fonction de multiplication 124
4 Annexe III : Spécification des fonctions d’entrée/sortie définies dans es.s 125
Equipe
Première partie
Documentation Technique
Equipe
Chapitre 1
Environnement informatique pour les

travaux pratiques
1.1 Connexion au serveur

Un serveur Linux : turing est disponible pour les TPs de 401 INF PUBLIC.
Depuis un poste du DLST : utiliser un logiciel de connexion à distance (typiquement putty,

xming ou cygwin/X) disponible sur le pc windows pour obtenir une bannnière de connexion sur turing.
Depuis une machine de type POSIX (unix, linux, macOS) : lancer la commande ssh -X -C
turing.e.ujf-grenoble.fr dans un terminal (Xterm, Konsole, etc) pour vous connecter.
1.2 Emplacement des fichiers

Les fichiers nécessaires pour effectuer chaque TP sont situés dans le répertoire :
/Public/401 INF PUBLIC/TP<i >, ou <i > désigne le numéro du TP.
Par exemple, les fichiers nécessaires pour la première séance sont situés dans le répertoire
/Public/401 INF PUBLIC/TP1. Lorsque le TP dure plus d’une séance le nom du répertoire porte
les numéros des deux séances, comme par exemple /Public/401 INF PUBLIC/TP3et4.
1.3 Configuration de la session de travail

Les opérations suivantes doivent être effectuées pour configurer une fois pour toutes votre environ-
nement de travail :
1. Se connecter à turing
2. Exécuter les commandes de configuration contenues dans le fichier config.sh au moyen de la
commande : source /Public/401 INF PUBLIC/config.sh
Vérifier que le répertoire /opt/gnu/arm/bin est bien en tête du chemin d’accès aux exécutables,
au moyen de la commande : echo $PATH
Cette opération installe une fois pour toutes l’environnement requis pour les TPs. Elle n’est à
exécuter qu’une seule fois. Elle n’aura pas à être ré-exécutée lors des autres séances.
Votre binôme doit ensuite répéter la même opération, afin que vous puissiez tous deux travailler
avec un environnement correct dans la suite du semestre :
— Il doit se connecter à son tour à turing (depuis un autre poste ou sur le même après que vous
vous soyez vous-même déconnecté).
Equipe
— Il doit ensuite exécuter sous son identité la commande :
source /Public/401 INF PUBLIC/config.sh
1.4 Démarrage d’une session de travail

Les opérations suivantes sont à effectuer au début de chaque séance :
1. Se connecter à turing.
2. Ouvrir une deuxième fenêtre au moyen de la commande : xterm & (Ctrl+clic central ou droit
pour options de configuration).
3. Copier le répertoire /Public/401 INF PUBLIC/TP<i > dans votre répertoire de travail. Par
exemple, pour le 1er TP utilisez la commande :
cp -r /Public/401 INF PUBLIC/TP1 .
(ne pas oublier le point à la fin de la commande précédente !...)
4. Effectuer les exercices décrits dans l’énoncé du TP.
1.5 TP1 : ressources disponibles

1.5.1 Fichiers
— Exo 1.1.1 : image.bm
— Exo 1.2.1 : lignes.xpm
— Exo 2.x : prog.c
— Exo 3 : prog1.s, prog1.var1.s, prog1.var2.s, prog1.var2.s
1.5.2 Outils
— nedit : création et modification de fichiers au format texte (gedit également disponible)..
— cat et less : visualisation de fichiers texte.
— bitmap : affichage d’une image monochrome au format bitmap.
— xli : visualisation de fichiers contenant une image.
— hexdump : visualisation en hexadécimal d’un fichier binaire ou texte.
— arm-eabi-gcc : compilateur C et assembleur pour processeur Arm.
— arm-eabi-objdump : utilitaire permettant d’observer le contenu d’un fichier binaire ayant été
produit par arm-eabi-gcc.
1.6 Quelques commandes utiles (rappels)

— Créer une copie d’un fichier existant (sans utiliser nedit :
cp <nom fichier original > <nom nouveau fichier >
Exemple : cp fich1.c fich2.c
ou bien :
cp <nom fichier original > <nom répertoire destination>
Exemple : cp fich1.c repA
— Renommer un fichier :
mv <nom original du fichier > <nouveau nom du fichier >
Exemple : mv fich1.c fich2.c
Equipe
— Déplacer un fichier :
mv <nom du fichier > <nom du répertoire destination>
Exemple : mv fich1.c ../repB
— Afficher (sans le modifier) le contenu d’un gros fichier (inutile d’utiliser nedit) :
less <nom du fichier > Exemple : less fich1.c
— Afficher (sans le modifier) le contenu d’un petit fichier (inutile d’utiliser nedit) :
cat <nom du fichier > Exemple : cat fich2.s
1.7 Commandes raccourcies

— armas <nom du fichier source .s>
Assemblage d’un fichier source. Le résultat est un fichier binaire translatable dont le nom est
suffixé par .o (prog.o dans l’exemple).
Exemple : armas prog.s
— armcc <nom du fichier source .c>

Compilation d’un fichier en langage C. Le résultat est un fichier binaire translatable dont le
nom est suffixé par .o (prog.o dans l’exemple).
Exemple : armcc prog.c
— armbuild <nom du fichier exécutable> <nom du fichier source> [<liste de fichiers .o à

ajouter éventuellement>]
Assemblage (ou compilation, pour un fichier en langage C) et production d’un exécutable.
Exemple 1 : armbuild prog1 prog1.s lib.o
Exemple 2 : armbuild prog2 prog2.c
— armrun <nom du fichier exécutable>

Exécution/simulation d’un fichier binaire exécutable.
Exemple : armrun prog
— armgdb <nom du fichier exécutable>

Mise au point d’un fichier binaire exécutable.
Exemple : armgdb prog
— armddd <nom du fichier exécutable>

Mise au point d’un fichier binaire exécutable (mode graphique).
Exemple : armddd prog
— armdata <nom du fichier ”objet” .o>

Observation de la section .data d’un fichier binaire translatable. Le résultat est affiché à
l’écran.
Exemple : armdata prog.o
— armdisas <nom du fichier ”objet” .o>

Observation/désassemblage de la section .text d’un fichier binaire translatable. Le résultat est
affiché à l’écran.
Exemple : armdisas prog.o
Equipe
Equipe
Chapitre 2
Langage machine et langage

d’assemblage ARM
2.1 Résumé de documentation technique ARM

2.1.1 Organisation des registres
Dans le mode dit “utilisateur” le processeur ARM a 16 registres visibles de taille 32 bits nommés
r0, r1, ..., r15 :
— r13 (synonyme sp, comme “stack pointer”) est utilisé comme registre pointeur de pile.
— r14 (synonyme lr comme “link register”) est utilisé par l’instruction ”branch and link” (bl)
pour sauvegarder l’adresse de retour lors d’un appel de procédure.
— r15 (synonyme pc, comme “program counter”) est le registre compteur de programme.
Les conventions de programmation des procédures (ATPCS=”ARM-Thumb Procedure Call Stan-
dard, Cf. Developer Guide, chapitre 2) précisent :
— les registres r0, r1, r2 et r3 sont utilisés pour le passage des paramètres (données ou
résultats)
— le registre r12 (synonyme ip) est un “intra-procedure call scratch register” ; autrement dit il
peut être modifié par une procédure appelée.
— le compilateur arm-eabi-gcc utilise le registre r11 (synonyme fp comme ”frame pointer”)
comme base de l’environnement de définition d’une procédure.
Le processeur a de plus un registre d’état, cpsr pour “Current Program Status Register”, qui
comporte entre autres les codes de conditions arithmétiques. Le registre d’état est décrit dans la
figure 2.1.
31 28 76 4 0
NZCV IF mode
Figure 2.1 – Registre d’état du processeur ARM
Les bits N, Z, C et V sont les codes de conditions arithmétiques, I et F permettent le masquage

des interruptions et mode définit le mode d’exécution du processeur (User, Abort, Supervisor, IRQ,
etc).
2.1.2 Les instructions

Nous utilisons trois types d’instructions : les instructions arithmétiques et logiques (para-
graphe 2.1.5), les instructions de rupture de séquence (paragraphe 2.1.6) et les instructions de transfert
Equipe
d’information entre les registres et la mémoire (paragraphe 2.1.7).
Les instructions sont codées sur 32 bits.
Certaines instructions peuvent modifier les codes de conditions arithmétiques N, Z, C, V en ajou-
tant un S au nom de l’instruction.
Toutes les instructions peuvent utiliser les codes de conditions arithmétiques en ajoutant un
mnémonique (Cf. figure 2.2) au nom de l’instruction. Au niveau de l’exécution, l’instruction est
exécutée si la condition est vraie.
2.1.3 Les codes de conditions arithmétiques

La figure 2.2 décrit l’ensemble des conditions arithmétiques.
code mnémonique signification condition testée

0000 EQ égal Z
0001 NE non égal Z
0010 CS/HS ≥ dans N C
0011 CC/LO < dans N C
0100 MI moins N
0101 PL plus N
0110 VS débordement V
0111 VC pas de débordement V
1000 HI > dans N C ∧Z
1001 LS ≤ dans N C ∨Z
1010 GE ≥ dans Z (N ∧ V ) ∨ (N ∧ V )
1011 LT < dans Z (N ∧ V ) ∨ (N ∧ V )
1100 GT > dans Z Z ∧ ((N ∧ V ) ∨ (N ∧ V ))
1101 LE ≤ dans Z Z ∨ (N ∧ V ) ∨ (N ∧ V )
1110 AL toujours
Figure 2.2 – Codes des conditions arithmétiques
Toute instruction peut être exécutée sous une des conditions décrites dans la figure 2.2. Le code
de la condition figure dans les bits 28 à 31 du code de l’instruction. Par défaut, la condition est AL.
2.1.4 Description de l’instruction de chargement d’un registre

Nous choisissons dans ce paragraphe de décrire en détail le codage d’une instruction.
L’instruction MOV permet de charger un registre avec une valeur immédiate ou de transférer la
valeur d’un registre dans un autre avec modification par translation ou rotation de cette valeur.
La syntaxe de l’instruction de transfert est : MOV [<COND>] [S] <rd>, <opérande> où rd désigne
le registre destination et opérande est décrit par la table ci-dessous :
opérande commentaire
#immédiate-8 entier sur 32 bits (Cf. remarque ci-dessous)
rm registre
rm, shift #shift-imm-5 registre dont la valeur est décalée d’un nombre
de positions représenté sur 5 bits
rm, shift rs registre dont la valeur est décalée du nombre
de positions contenu dans le registre rs
Equipe
Dans la table précédente le champ shift de l’opérande peut être LSL, LSR, ASR, ROR qui signi-
fient respectivement “logical shift left”, “logical shift right”, “arithmetic shift right”, “rotate right”.
Une valeur immédiate est notée selon les mêmes conventions que dans le langage C ; ainsi elle peut
être décrite en décimal (15), en hexadécimal (0xF) ou en octal (O17).
Le codage de l’instruction MOV est décrit dans les figures 2.3 et 2.4. <COND> désigne un mnémonique
de condition ; s’il est omis la condition est AL. Le bit S est mis à 1 si l’on souhaite une mise à jour des
codes de conditions arithmétiques. Le bit I vaut 1 dans le cas de chargement d’une valeur immédiate.
Les codes des opérations LSL, LSR, ASR, ROR sont respectivement : 00, 01, 10, 11.
Remarque concernant les valeurs immédiates : Une valeur immédiate sur 32 bits (opérande
#immediate) sera codée dans l’instruction au moyen, d’une part d’une constante exprimée sur 8 bits
(bits 7 à 0 de l’instruction, figure 2.4, 1er cas), et d’autre part d’une rotation exprimée sur 4 bits (bits
11 à 8) qui sera appliquée à la dite constante lors de l’exécution de l’instruction.
La valeur de rotation, comprise entre 0 et 15, est multipliée par 2 lors de l’exécution et permet
donc d’appliquer à la constante une rotation à droite d’un nombre pair de positions compris entre 0
et 30. La rotation s’applique aux 8 bits placés initialement à droite dans un mot de 32 bits (qui n’est
pas celui qui contient l’instruction).
Il en résulte que ne peuvent être codées dans l’instruction toutes les valeurs immédiates sur 32
bits...
Une rotation nulle permettra de coder toutes les valeurs immédiates sur 8 bits.
31 28 27 26 25 24 21 20 19 16 15 12 11 0
cond 00 I 1101 S 0000 rd opérande
Figure 2.3 – Codage de l’instruction mov
11 8 7 0
0000 immediate-8
11 7 65 3 0
shift-imm-5 shift 0 rm
11 8 65 3 0
rs 0 shift 1 rm
Figure 2.4 – Codage de la partie opérande d’une instruction
Exemples d’utilisations de l’instruction mov
MOV r1, #42 @ r1 <-- 42

MOV r3, r5 @ r3 <-- r5
MOV r2, r7, LSL #28 @ r2 <-- r7 décalé à gauche de 28 positions
MOV r1, r0, LSR r2 @ r1 <-- r0 décalé à droite de n pos., r2=n
MOVS r2, #-5 @ r2 <-- -5 + positionnement N, Z, C et V
MOVEQ r1, #42 @ si cond(EQ) alors r1 <-- 42
MOVLTS r3, r5 @ si cond(LT) alors r3 <-- r5 + positionnement N, Z, C et V
Equipe
2.1.5 Description des instructions arithmétiques et logiques
Les instructions arithmétiques et logiques ont pour syntaxe :

code-op[<cond>][s] <rd>, <rn>, <opérande>, où code-op est le nom de l’opération, rn et
opérande sont les deux opérandes et rd le registre destination.
Le codage d’une telle instruction est donné dans la figure 2.5. opérande est décrit dans le para-
graphe 2.1.4, figure 2.4.
31 28 27 26 25 24 21 20 19 16 15 12 11 0
cond 00 I code-op S rn rd opérande
Figure 2.5 – Codage d’une instruction arithmétique ou logique
La table ci-dessous donne la liste des intructions arithmétiques et logiques ainsi que les instructions
de chargement d’un registre. Les instructions TST, TEQ, CMP, CMN n’ont pas de registre destination,
elles ont ainsi seulement deux opérandes ; elles provoquent systématiquement la mise à jour des codes
de conditions arithmétiques (dans le codage de l’instruction les bits 12 à 15 sont mis à zéro). Les
instructions MOV et MVN ont un registre destination et un opérande (dans le codage de l’instruction les
bits 16 à 19 sont mis à zéro).
code-op Nom Explication du nom Opération remarque

0000 AND AND et bit à bit
0001 EOR Exclusive OR ou exclusif bit à bit
0010 SUB SUBstract soustraction
0011 RSB Reverse SuBstract soustraction inversée
0100 ADD ADDition addition
0101 ADC ADdition with Carry addition avec retenue
0110 SBC SuBstract with Carry soustraction avec emprunt
0111 RSC Reverse Substract with Carry soustraction inversée avec emprunt
1000 TST TeST et bit à bit pas rd
1001 TEQ Test EQuivalence ou exclusif bit à bit pas rd
1010 CMP CoMPare soustraction pas rd
1011 CMN CoMpare Not addition pas rd
1100 ORR OR ou bit à bit
1101 MOV MOVe copie pas rn
1110 BIC BIt Clear et not bit à bit
1111 MVN MoVe Not not (complément à 1) pas rn
Exemples d’utilisations
ADD r1, r2, r5 @ r1 <-- r2 + r5

ADDS r0, r2, #4 @ r0 <-- r2 + 4 + positionnement NZCV
SUB r3, r7, r0 @ r3 <-- r7 - r0
SUBS r3, r7, r0 @ r3 <-- r7 - r0 + positionnement NZCV
SUBGES r3, r7, r0 @ si cond(GE) r3 <-- r7 - r0 et positionnement NZCV
CMP r1, r2 @ calcul de r1-r2 et positionnement NZCV
TST r3, #1 @ calcul de r3 ET 1 et positionnement NZCV
ANDS r1, r2, #0x0000ff00 @ r1 <-- r2 ET 0x0000ff00 et positionnement NZCV
Equipe
2.1.6 Description des instructions de rupture de séquence
Nous utilisons trois instructions de rupture de séquence : B[<cond>] <déplacement>, BL[<cond>]
<déplacement>, BLX[<cond>] <registre>.
a) Instruction B[<cond>] <déplacement> L’instruction B provoque la modification du compteur

de programme si la condition est vraie ; le texte suivant est extrait de la documentation ARM :
if ConditionPassed(cond) then
PC <-- PC + (SignExtend(déplacement) << 2)
L’expression (SignExtend(déplacement) << 2) signifie que le déplacement est tout d’abord

étendu de façon signée à 32 bits puis mutiplié par 4. Le déplacement est en fait un entier relatif
(codé sur 24 bits comme indiqué ci-dessous) et qui représente le nombre d’instructions (en avant ou
en arrière) entre l’instruction de rupture de séquence et la cible de cette instruction.
Dans le calcul du déplacement, il faut prendre en compte le fait que lors de l’exécution d’une
instruction, le compteur de programme ne repère pas l’instruction courante mais deux instructions en
avant.
31 28 27 25 24 23 0
cond 101 0 déplacement
Figure 2.6 – Codage de l’instruction de rupture de séquence b{cond}
BEQ +5 @ si cond(EQ) alors pc <-- pc + 4*5

BAL -8 @ pc <-- pc - 4*8
Dans la pratique, on utilise une étiquette (Cf. paragraphe 2.2.4) pour désigner l’instruction cible
d’un branchement. C’est le traducteur (i.e. l’assembleur) qui effectue le calcul du déplacement.
La figure 2.7 résume l’utilisation des instructions de branchements conditionnels après une com-
paraison.
Conditions des instructions de branchement conditionnel

Type Entiers relatifs (Z) Naturels (N) et adresses
Instruction C Bxx Condition Bxx Condition
goto BAL 1110 BAL 1110
if (x== y) goto BEQ 0000 BEQ 0000
if (x != y) goto BNE 0001 BNE 0001
if (x < y) goto BLT 1011 BLO, BCC 0011
if (x<= y) goto BLE 1101 BLS 1001
if (x > y) goto BGT 1100 BHI 1000
if (x>= y) goto BGE 1010 BHS,BCS 0010
Figure 2.7 – Utilisation des branchements conditionnels après une comparaison
Equipe
b) Instruction BL[<cond>] <déplacement> L’instruction BL provoque la modification du comp-
teur de programme avec sauvegarde de l’adresse de l’instruction suivante (appelée adresse de
retour) dans le registre lr ; le texte suivant est extrait de la documentation ARM :
lr <-- address of the instruction after the branch instruction

PC <-- PC + (SignExtend(déplacement) << 2)
31 28 27 25 24 23 0
cond 101 1 déplacement
Figure 2.8 – Codage de l’instruction de branchement à un sous-programme bl
BL 42 @ lr <-- pc+4 ; pc <-- pc +4*42
c) Instruction BLX[<cond>] <registre> L’instruction BLX Rm provoque la modification du comp-

teur de programme avec sauvegarde de l’adresse de l’instruction suivante (appelée adresse de
retour) dans le registre lr ; le texte suivant est extrait de la documentation ARM :
lr <-- address of the instruction after the branch instruction

PC <-- Rm
Attention : Dans le cadre des TP, l’adresse passée en paramètre à BLX doit être paire. En effet,
l’exécution de BLX avec une adresse impaire active un mode spécial du processeur (THUMB) avec un
autre jeu d’instructions (codées sur 16 bits). Ce type d’erreur peut avoir des effets assez variés en
fonction du programme concerné : on peut obtenir un message d’erreur relatif au mode THUMB ou
un comportement arbitraire du simulateur.
BLX R5 @ lr <-- pc+4 ; pc <-- R5
Pour désigner une procédure on utilisera une étiquette ; des exemples sont donnés dans le para-
graphe 2.2.4.
2.1.7 Description des instructions de transfert d’information entre les registres et

la mémoire
Transfert entre un registre et la mémoire
L’instruction LDR dont la syntaxe est : LDR <rd>, <mode-adressage> permet le transfert du mot
mémoire dont l’adresse est spécifiée par mode-adressage vers le registre rd. Nous ne donnons pas
le codage de l’instruction LDR parce qu’il comporte un grand nombre de cas ; nous regardons ici
uniquement les utilisations les plus fréquentes de cette instruction.
Le champ mode-adressage comporte, entre crochets, un registre et éventuellement une valeur
immédiate ou un autre registre, ceux-ci pouvant être précédés du signe + ou −. Le tableau ci-dessous
indique pour chaque cas le mot mémoire qui est chargé dans le registre destination. L’instruction ldr
permet beaucoup d’autres types de calcul d’adresse qui ne sont pas décrits ici.
Equipe
mode-adressage opération effectuée
[rn] rd <– mem [rn]
[rn, #offset12] rd <– mem [rn + offset12]
[rn, #-offset12] rd <– mem [rn - offset12]
[rn, rm] rd <– mem [rn + rm]
[rn, -rm] rd <– mem [rn - rm]
Il existe des variantes de l’instruction LDR permettant d’accéder à un octet : LDRB ou à un mot
de 16 bits : LDRH. Et si l’on veut accéder à un octet signé : LDRSB ou à un mot de 16 bits signé :
LDRSH. Ces variantes imposent cependant des limitations d’adressage par rapport aux versions 32 bits
(exemple : valeur immédiate codée sur 5 bits au lieu de 12).
Pour réaliser le transfert inverse, registre vers mémoire, on trouve l’instruction STR et ses variantes
STRB et STRH. La syntaxe est la même que celle de l’instruction LDR. Par exemple, l’instruction STR
rd, [rn] provoque l’exécution : MEM [rn] <-- rd.
LDR r1, [r0] @ r1 <-32bits-- Mem [r0]

LDR r3, [r2, #4] @ r3 <-32bits-- Mem [r2 + 4]
LDR r3, [r2, #-8] @ r3 <-32bits-- Mem [r2 - 8]
LDR r3, [pc, #48] @ r3 <-32bits-- Mem [pc + 48]
LDRB r5, [r3] @ 8bits_poids_faibles (r5) <-- Mem [r3],
@ extension aux 32 bits avec des 0
STRH r2, [r1, r3] @ Mem [r1 + r3] <-16bits-- 16bits_poids_faibles (r2)
L’instruction LDR est utilisée entre autres pour accéder à un mot de la zone text en réalisant
un adressage relatif au compteur de programme. Ainsi, l’instruction LDR r2, [pc, #depl] permet de
charger dans le registre r2 avec le mot mémoire situé à une distance depl du compteur de programme,
c’est-à-dire de l’instruction en cours d’exécution. Ce mode d’adressage nous permet de recupérer
l’adresse d’un mot de données (Cf. paragraphe 2.2.4).
Pré décrémentation et post incrémentation
Les instructions LDR et STR offrent des adressages post-incrémentés et pré-décrémentés qui per-
mettent d’accéder à un mot de la mémoire et de mettre à jour une adresse, en une seule instruction.
Cela revient à combiner un accès mémoire et l’incrémentation du pointeur sur celle-ci en une seule
instruction.
instruction ARM équivalent ARM équivalent C
LDR r1, [r2, #-4]! SUB r2, r2, #4 r1 = *--r2
LDR r1, [r2]
LDR r1, [r2], #4 LDR r1, [r2] r1 = *r2++
ADD r2, r2, #4
STR r1, [r2, #-4]! SUB r2, r2, #4
STR r1, [r2]
STR r1, [r2], #4 STR r1, [r2]
ADD r2, r2, #4
La valeur à incrémenter ou décrémenter (4 dans les exemples ci-dessus) peut aussi être donnée
dans un registre.
Equipe
Transfert multiples
Le processeur ARM possède des instructions de transfert entre un ensemble de registres et

un bloc de mémoire repéré par un registre appelé registre de base : LDM et STM. Par exemple,
STMFD r7!, {r0,r1,r5} range le contenu des registres r0, r1 et r5 dans la mémoire et met à jour
le registre r7 suite le transfert (i.e. r7 = r7 - 12) ; après l’exécution de l’instruction MEM[ r7 à jour
] contient r0 et MEM[ r7 à jour + 8 ] contient r5.
Il existe 8 variantes de chacune des instructions LDM et STM selon que :
— les adresses de la zone mémoire dans laquelle sont copiés les registres croissent (Increment) ou
décroissent (Decrement).
— l’adresse contenue dans le registre de base est incrémentée ou décrémentée avant (Before) ou
après (After) le transfert de chaque registre. Notons que l’adresse est décrémentée avant le
transfert quand le registre de base repère le mot qui a l’adresse immédiatement supérieure à
celle où l’on veut ranger une valeur (Full) ; l’adresse est incrémentée après le transfert quand
le registre de base repère le mot où l’on veut ranger une valeur (Empty).
— le registre de base est modifié à la fin de l’exécution quand il est suivi d’un ! ou laissé inchangé
sinon.
Ces instructions servent aussi à gérer une pile. Il existe différentes façons d’implémenter une pile
selon que :
— le pointeur de pile repère le dernier mot empilé (Full) ou la première place vide (Empty).
— le pointeur de pile progresse vers les adresses basses quand on empile une information
(Descending) ou vers les adresses hautes (Ascending).
Par exemple, dans le cas où le pointeur de pile repère l’information en sommet de pile (case pleine)
et que la pile évolue vers les adresses basses (lorsque l’on empile l’addresse décroit), on parle de pile
Full Descending et on utilise l’instruction STMFD pour empiler et LDMFD pour dépiler.
Les modes de gestion de la pile peuvent être caractérisés par la façon de modifier le pointeur de pile
lors de l’empilement d’une valeur ou de la récupération de la valeur au sommet de la pile. Par exemple,
dans le cas où le pointeur de pile repère l’information en sommet de pile et que la pile évolue vers
les adresses basses, pour empiler une valeur il faut décrémenter le pointeur de pile avant le stockage
en mémoire ; on utilisera l’instruction STMDB (Decrement Before). Dans le même type d’organisation
pour dépiler on accède à l’information au sommet de pile puis on incrémente le pointeur de pile : on
utilise alors l’instruction LDMIA (Increment After).
Selon que l’on prend le point de vue gestion d’un bloc de mémoire repéré par un registre ou gestion
d’une pile repérée par le registre pointeur de pile, on considère une instruction ou une autre ... Ainsi,
les instructions STMFD et STMDB sont équivalentes ; de même pour les instructions LDMFD et LDMIA.
Les tables suivantes donnent les noms des différentes variantes des instructions LDM et STM, chaque
variante ayant deux noms synonymes l’un de l’autre.
nom de l’instruction synonyme

LDMDA (decrement after) LDMFA (full ascending)
LDMIA (increment after) LDMFD (full descending)
LDMDB (decrement before) LDMEA (empty ascending)
LDMIB (increment before) LDMED (empty descending)
nom de l’instruction synonyme

STMDA (decrement after) STMED (empty descending)
STMIA (increment after) STMEA (empty ascending)
STMDB (decrement before) STMFD (full descending)
STMIB (increment before) STMFA (full ascending)
Equipe
adresses 0 0
croissantes
r7
r3
r4
r5
r6
r7
max max
a) b)
Figure 2.9 – Transfert multiples mémoire/registres : STMFD r7!, {r3,r4,r5,r6} ou (STMDB ...)
permet de passer de l’état a) de la mémoire à l’état b). LDMFD r7!, {r3,r4,r5,r6} (ou LDMIA ...)
réalise l’inverse.
La figure 2.9 donne un exemple d’utilisation.
2.2 Langage d’assemblage

2.2.1 Structure d’un programme en langage d’assemblage
Un programme est composé de trois types de sections :
— données intialisées ou non (.data)
— données non initialisées (.bss)
— instructions (.text)
Les sections de données sont optionnelles, celle des instructions est obligatoire. On peut écrire des
commentaires entre le symbole @ et la fin de la ligne courante. Ainsi un programme standard a la
structure :
.data
@ déclaration de données
@ ...
.text
@ des instructions
@ ...
2.2.2 Déclaration de données

Le langage permet de déclarer des valeurs entières en décimal (éventuellement précédées de leur
signe) ou en hexadécimal ; on précise la taille souhaitée.
Exemple :
.data
.word 4536 @ déclaration de la valeur 4536 sur 32 bits (1 mot)
Equipe
.hword -24 @ déclaration de la valeur -24 sur 16 bits (1 demi mot)
.byte 5 @ déclaration de la valeur 5 sur 8 bits (1 octet)
.word 0xfff2a35f @ déclaration d’une valeur en hexadécimal sur 32 bits
.byte 0xa5 @ idem sur 8 bits
On peut aussi déclarer des chaı̂nes de caractères suivies ou non du caractère de code ASCII 00.
Un caractère est codé par son code ASCII (Cf. paragraphe 1).
Exemple :
.data
.ascii "un texte" @ déclaration de 8 caractères...
.asciz "un texte" @ déclaration de 9 caractères, les m^
emes que ci-dessus
@ plus le code 0 à la fin
La définition de données doit respecter les règles suivantes, qui proviennent de l’organisation phy-
sique de la mémoire :
— un mot de 32 bits doit être rangé à une adresse multiple de 4
— un mot de 16 bits doit être rangé à une adresse multiple de 2
— il n’y a pas de contrainte pour ranger un octet (mot de 8 bits)
Pour recadrer une adresse en zone data le langage d’assemblage met à notre disposition la directive
.balign.
Exemple :
.data
@ on note AD l’adresse de chargement de la zone data
@ que l’on suppose multiple de 4 (c’est le cas avec les outils utilisés)
.hword 43 @ après cette déclaration la prochaine adresse est AD+2
.balign 4 @ recadrage sur une adresse multiple de 4
.word 0xffff1234 @ rangé à l’adresse AD+4
.byte 3 @ après cette déclaration la prochaine adresse est AD+9
.balign 2 @ recadrage sur une adresse multiple de 2
.hword 42 @ rangé à l’adresse AD+10
On peut aussi réserver de la place en zone .data ou en zone .bss avec la directive .skip.
.skip 256 réserve 256 octets qui ne sont pas initialisés lors de la réservation. On pourra par programme
écrire dans cette zone de mémoire.
2.2.3 La zone text

Le programmeur y écrit des instructions qui seront codées par l’assembleur (le traducteur) selon
les conventions décrites dans le paragraphe 2.1.
La liaison avec le système (chargement et lancement du programme) est réalisée par la définition
d’une étiquette (Cf. paragraphe suivant) réservée : main.
Ainsi la zone text est :
.text
.global main
main:
@ des instructions ARM

@ ...
Equipe
2.2.4 Utilisation d’étiquettes
Une donnée déclarée en zone data ou bss ou une instruction de la zone text peut être précédée
d’une étiquette. Une étiquette représente une adresse et permet de désigner la donnée ou l’instruction
concernée.
Les étiquettes représentent une facilité d’écriture des programmes en langage d’assemblage.
Expression d’une rupture de séquence

On utilise une étiquette pour désigner l’instruction cible d’un branchement. C’est le traducteur
(i.e. l’assembleur) qui effectue le calcul du déplacement. Par exemple :
etiq: MOV r0, #22

ADDS r1, r2, r0
BEQ etiq
Accès à une donnée depuis la zone text

.data
DD: .word 5
.text
@ acces au mot d’adresse DD

LDR r1, relais @ r1 <-- l’adresse DD
LDR r2, [r1] @ r2 <-- Mem[DD] c’est-à-dire 5
MOV r3, #245 @ r3 <-- 245

STR r3, [r1] @ Mem[DD] <-- r3
@ la mémoire d’adresse DD a été modifiée
@ plus loin
relais: .word DD @ déclaration de l’adresse DD en zone text
L’instruction LDR r1, relais est codée avec un adressage relatif au compteur de programme :
LDR r1, [pc, #depl] (Cf. paragraphe 2.1.7).
Appel d’une procédure

On utilise l’instruction BL lorsque la procédure appelée est désignée directement par une étiquette :
...
ma_proc: @ corps de la procedure
mov pc, lr
...
@ appel de la procedure ma_proc
BL ma_proc
On utilise l’instruction BLX lorsque l’adresse de la procédure est rangée dans un registre, par
exemple lorsqu’une procédure est passée en paramètre :
Equipe
LDR r1, adr_proc @ r1 <-- adresse ma_proc
BLX r1
...
adr_proc: .word ma_proc
2.3 Organisation de la mémoire : petits bouts, gros bouts

La mémoire du processeur ARM peut être vue comme un tableau d’octets repérés par des numéros
appelés adresse qui sont des entiers naturels sur 32 bits. On peut ranger dans la mémoire des mots
de 32 bits, de 16 bits ou des octets (mots de 8 bits). Le paragraphe 2.2.2 indique comment déclarer
de tels mots.
Dans la mémoire les mots de 32 bits sont rangés à des adresses multiples de 4. Il y a deux conventions
de rangement de mots en mémoire selon l’ordre des octets de ce mot.
Considérons par exemple le mot 0x12345678.
— convention dite ”Big endian” (Gros bouts) :
les 4 octets 12, 34, 56, 78 du mot 0x12345678 sont rangés aux adresses respectives 4x, 4x+1,
4x+2, 4x+3.
— convention dite ”Little endian” (Petits Bouts) :
les 4 octets 12, 34, 56, 78 du mot 0x12345678 sont rangés aux adresses respectives 4x+3,
4x+2, 4x+1, 4x.
Le processeur ARM suit la convention ”Little endian”. La conséquence est que lorsqu’on lit le mot
de 32 bits rangé à l’adresse 4x on voit : 78563412, c’est-à-dire qu’il faut lire ”à l’envers”. Selon les
outils utilisés le mot de 32 bits est présenté sous cette forme ou sous sa forme externe, plus agréable...
En général les outils de traduction et de simulation permettent de travailler avec une des
deux conventions moyennant l’utilisation d’options particulières lors de l’appel des outils (option
-mbig-endian).
2.4 Commandes de traduction, exécution, observation

2.4.1 Traduction d’un programme
Pour traduire un programme écrit en C contenu dans un fichier prog.c :
arm-eabi-gcc -g -o prog prog.c. L’option -o permet de préciser le nom du programme exécutable ;
o signifie “output”. L’option -g permet d’avoir les informations nécessaires à la mise au point sous
débogueur (Cf. paragraphe 2.4.2).
Pour traduire un programme écrit en langage d’assemblage ARM contenu dans un fichier prog.s :
arm-eabi-gcc -Wa,--gdwarf2 -o prog prog.s.
Lorsque l’on veut traduire un programme qui est contenu dans plusieurs fichiers que l’on devra
rassembler (on dit “lier”), il faut d’abord produire des versions partielles qui ont pour suffixe .o, le o
voulant dire ici “objet”. Par exemple, on a deux fichiers : principal.s et biblio.s, le premier contenant
l’étiquette main. On effectuera la suite de commandes :
arm-eabi-gcc -c -Wa,--gdwarf2 biblio.s

arm-eabi-gcc -c -Wa,--gdwarf2 principal.s
arm-eabi-gcc -g -o prog principal.o biblio.o
La première produit le fichier biblio.o, la seconde produit le fichier principal.o, la troisième

les relie et produit le fichier exécutable prog.
Noter que les deux commandes suivantes ont le même effet :
arm-eabi-gcc -c prog.s et
Equipe
arm-eabi-as -o prog.o prog.s. Elles produisent toutes deux un fichier objet prog.o sans les infor-
mations nécessaires à l’exécution sous débogueur.
2.4.2 Exécution d’un programme

Exécution directe
On peut exécuter un programme directement avec :
arm-eabi-run prog. S’il n’y a pas d’entrées-sorties, on ne voit évidemment rien...
Exécution avec un débogueur

Nous pouvons utiliser deux versions du même débogueur : gdb et ddd. On parle aussi de metteur
au point. C’est un outil qui permet d’exécuter un programme instruction par instruction en regardant
les “tripes” du processeur au cours de l’exécution : valeur contenues dans les registres, dans le mot
d’état, contenu de la mémoire, etc.
gdb est la version de base (textuelle), ddd est la même mais graphique (avec des fenêtres, des
icônes, etc.), elle est plus conviviale mais plus sujette à des problèmes techniques liés à l’installation
du logiciel. . .
Soit le programme objet exécutable : prog. Pour lancer gdb :
arm-eabi-gdb prog. Puis taper successivement les commandes : target sim et enfin load. Mainte-
nant on peut commencer la simulation.
Pour éviter de taper à chaque fois les deux commandes précédentes, vous pouvez créer un fichier
de nom .gdbinit dont le contenu est :
# un diese débute un commentaire

# commandes de demarrage pour arm-eabi-gdb
target sim
load
Au lancement de arm-eabi-gdb prog, le contenu de ce fichier sera automatiquement exécuté.

Voilà un ensemble de commandes utiles :
— placer un point d’arrêt sur une instruction précédée d’une étiquette, par exemple : break main.
On peut aussi demander break no avec no un numéro de ligne dans le code source. Un raccourci
pour la commande est b.
— enlever un point d’arrêt : delete break numéro du point d’arr^ et
— voir le code source : list
— lancer l’exécution : run
— poursuivre l’exécution après un arrêt : cont, raccourci : c
— exécuter l’instruction à la ligne suivante, en entrant dans les procédures : step, raccourci s
— exécuter l’instruction suivante (sans entrer dans les procédures) : next, raccourci n
— voir la valeur contenue dans les registres : info reg
— voir la valeur contenue dans le registre r1 : info reg $r1
— voir le contenu de la mémoire à l’adresse etiquette : x &etiquette
— voir le contenu de la mémoire à l’adresse 0x3ff5008 : x 0x3ff5008
— voir le contenu de la mémoire en précisant le nombre de mots et leur taille.
x /nw adr permet d’afficher n mots de 32 bits à partir de l’adresse adr.
x /ph adr permet d’afficher p mots de 16 bits à partir de l’adresse adr.
— modifier le contenu du registre r3 avec la valeur 0x44 exprimée en hexadécimal : set $r3=0x44
— modifier le contenu de la mémoire d’adresse etiquette : set *etiquette = 0x44
— sortir : quit
— La touche Enter répète la dernière commande.
Equipe
Et ne pas oublier : man gdb sous Unix (ou Linux) et quand on est sous gdb : help
nom de commande. . .
Pour lancer ddd : ddd --debugger arm-eabi-gdb. On obtient une grande fenêtre avec une par-
tie dite “source” (en haut) et une partie dite “console” (en bas). Dans la fenêtre “console” taper
successivement les commandes : file prog, target sim et enfin load.
On voit apparaı̂tre le source du programme en langage d’assemblage dans la fenêtre “source” et
une petite fenêtre de “commandes”. Maintenant on peut commencer la simulation.
Toutes les commandes de gdb sont utilisables soit en les tapant dans la fenêtre “console”, soit en
les sélectionnant dans le menu adéquat. On donne ci-dessous la description de quelques menus. Pour
le reste, il suffit d’essayer.
— placer un point d’arrêt : sélectionner la ligne en question avec la souris et cliquer sur l’icône
break (dans le panneau supérieur).
— démarrer l’exécution : cliquer sur le bouton Run de la fenêtre “commandes”. Vous voyez ap-
paraı̂tre une flèche verte qui vous indique la position du compteur de programme i.e. où en est
le processeur de l’exécution de votre programme.
— le bouton Step permet l’exécution d’une ligne de code, le bouton Next aussi mais en entrant
dans les procédures et le bouton Cont permet de poursuivre l’exécution.
— enlever un point d’arrêt : se positionner sur la ligne désirée et cliquer à nouveau sur l’icône
break.
— voir le contenu des registres : sélectionner dans le menu Status : Registers ; une fenêtre apparaı̂t.
La valeur contenue dans chaque registre est donnée en hexadécimal (0x...) et en décimal.
— observer le contenu de la memoire étiquettée etiquette : apres avoir sélectionné memory dans
le menu Data, on peut soit donner l’adresse en hexadecimal 0x... si on la connaı̂t, soit donner
directement le nom etiquette dans la case from en le précédant du caractère &, c’est-à-dire
&etiquette.
2.4.3 Observation du code produit

Considérons un programme objet : prog.o obtenu par traduction d’un programme écrit en langage
C ou en langage d’assemblage. L’objet de ce paragraphe est de décrire l’utilisation d’un ensemble
d’outils permettant d’observer le contenu du fichier prog.o. Ce fichier contient les informations du
programme source codées et organisées selon un format appelé format ELF.
On utilise trois outils : hexdump, arm-eabi-readelf, arm-eabi-objdump.
hexdump donne le contenu du fichier dans une forme brute.
hexdump prog.o donne ce contenu en hexadécimal complété par le caractère correspondant quand
une valeur correspond à un code ascii ; de plus l’outil indique les adresses des informations contenues
dans le fichier en hexadécimal aussi.
arm-eabi-objdump permet d’avoir le contenu des zones data et text avec les commandes respec-
tives :
arm-eabi-objdump -j .data -s prog.o et
arm-eabi-objdump -j .text -s prog.o. Ce contenu est donné en hexadécimal. On peut obtenir la
zone text avec le désassemblage de chaque instruction :
arm-eabi-objdump -j .text -d prog.o.
arm-eabi-readelf permet d’avoir le contenu du reste du fichier.
arm-eabi-readelf -a prog.o donne l’ensemble des sections contenues dans le fichier sauf les zones
data et text.
arm-eabi-readelf -s prog.o donne le contenu de la table des symboles.
Equipe
Deuxième partie
Travaux Dirigés
Equipe
Chapitre 1
TD séance 1 : Codage
1.1 Codage binaire, hexadécimal de nombres entiers naturels

Ecrire les 16 premiers entiers en décimal, binaire et hexadécimal.
1.2 Codage ASCII

Regarder la table de codes ascii qui est en annexe.
Sur combien de bits est codé un caractère ?
Soit la fonction : code ascii : un caractère --> un entier ∈ [0, 127].

Comment passe-t-on du code d’une lettre majuscule au code d’une lettre minuscule ou l’inverse.
Quelle opération faut-il faire ?
1.3 Codage par champs : codage d’une date

On veut coder une information du style : lundi 12 janvier.
Codage du jour de la semaine : lun :0,...,dim :6, il faut 3 bits
Codage du quantième du jour dans le mois : 1..31, 5 bits
Codage du mois : 1..12, 4 bits
Quel est le code de la date : lundi 12 janvier ?

Quelle est la date associée au code 001 00011 0001 ?
Quel est la date associée au code 111 11111 1111 ?
1.4 Code d’une instruction ARM

C’est un autre type de codage par champs.
En utilisant la doc technique, coder en binaire les instructions ARM : MOV r5, r7,
MOV r5, #7.
Exercice à faire à la maison : codage d’une instruction add.
1.5 Codage d’un nombre entre 16 et 255

Combien faut-il de bits ? Coder les valeurs 17, 67, 188 en binaire et en hexadécimal. En déduire
une méthode rapide de passage binaire vers hexadécimal ainsi que l’inverse.
Equipe
ROUGE
VIOLET BLEU
BLANC
JAUNE CYAN
VERT
Figure 1.1 – Codage de couleurs
1.6 Codage de nombres à virgule

On représente des nombres à virgule de l’intervalle [0, 16[ par un octet selon le code suivant : les 4
bits de poids forts codent la partie entière, Les 4 bits de poids faibles codent la partie après la virgule 1 .
Par exemple 01101010 représente 6,625. En effet x3 x2 x1 x0 x−1 x−2 x−3 x−4 = 01101010 donne
X = 4 + 2 + 21 + 18 = 6,625. (Rappelons que les anglo-saxons le notent 6.625)
rang du bit 3 2 1 0 -1 -2 -3 -4
bit 0 1 1 0 1 0 1 0
valeur arithmétique correspondante 8 4 2 1 12 1
4
1
8
1
16
P3
Dans le cas général on a : X = i=−4 2i × xi
Que représente le vecteur 00010100 ?
Donner l’écriture binaire de 5,125.
Quel est le plus grand nombre représentable selon ce code ?
Peut-on représenter 37 ou 58 ?
1.7 Codage de couleurs

Codage des 16 couleurs sur les premiers PC couleurs : Ici, il y a un bit de rouge, un bit de vert,
un bit de bleu et un bit de clair. Ainsi on voit que cobalt est cyan pale, rose est rouge pale, mauve est
violet pale, jaune est brun pale et blanc est gris pale. La figure 1.1 montre les “mélanges”.
B b3 b2 b1 b0 B b3 b2 b1 b0 B b3 b2 b1 b0
0 0 0 0 0 noir 5 0 1 0 1 violet 10 1 0 1 0 vertpâle
1 0 0 0 1 bleu 6 0 1 1 0 brun 11 1 0 1 1 cobalt
2 0 0 1 0 vert 7 0 1 1 1 gris 12 1 1 0 0 rose
3 0 0 1 1 cyan 8 1 0 0 0 noir pâle 13 1 1 0 1 mauve
4 0 1 0 0 rouge 9 1 0 0 1 bleu pâle 14 1 1 1 0 jaune
15 1 1 1 1 blanc
1. on ne dit pas décimale car ce mot est impropre ici mais c’est quand même le mot habituel
Equipe
Chapitre 2
TD séance 2 : Représentation des

nombres
2.1 Introduction
Un entier E peut être représenté par uneP suite de n chiffres (ou digits) ei , tous inférieurs à la base
n−1
utilisée (0 ≤ ei ≤ B − 1) et tels que E = i=0 ei ∗ B i . Chaque chiffre ei représente le reste de la
i
division entière de E/B par B. La base B est éventuellement précisée en indice à droite du dernier
chiffre ou entre parenthèses. Par défaut, il s’agit de la base 10.
L’entier composé des k chiffres de poids faibles de E est E modulo 1 2k et celui composé des n-k
chiffres de poids forts de E est E / 2k . Exemple pour n=5 et k=2 :
2310 = 5 ∗ 4 + 3 = 101112 . (10111) : 23/4 = 5 = 1012 . 23 modulo 4 = 3 = 112
Les organes d’un ordinateur sont dimensionnés à un nombre fixe n de bits. Par exemple, les
registres, les unités de calcul, le bus d’accès à la mémoire d’un ARM7 sont tous dimensionnés à 32
bits : le résultat d’une opération est stocké avec le même nombre de bits que ses opérandes. Tous les
calculs sont donc réalisés modulo 2n (environ quatre milliards pour n = 32 bits).
La table en annexe 2 donne les principales puissances de 2, ainsi que la valeur binaire et décimale
de chaque chiffre hexadécimal.
1012 = 1 × 22 + 0 × 21 + 1 × 20 = 4+1 = 510

10110 = 1 × 102 + 0 × 101 + 1 × 100 = 100 + 1 = 10110
10116 = 1 × 162 + 0 × 161 + 1 × 160 = 256 + 1 = 25710
A416 = 10 × 161 + 4 × 160 = 10 ∗ 16 + 4 = 16410
Conversions entre bases 2, 10 et 16 :
1. 2 vers 16 : ajouter éventuellement des 0 à gauche pour avoir 4k bits, convertir les k quartets
en k chiffres hexadécimaux.
2. 16 vers 2 : convertir chaque chiffre hexadécimal en quartet de bits
3. 10 vers B=2 ou B=16 : diviser par B, le reste donne un chiffre (poids faible), recommencer avec
le quotient, etc : le dernier reste non nul donne le chiffre de poids fort.
Exemples :
17810 = B216 : 178/16 quotient 11, reste 2 (poids f aible), 11/16 : quotient 0 reste 11( B (poidsf ort))
1. modulo = reste de la division entière
Equipe
1110 = 10112 = 5 ∗ 2 + 1 (poids f aible), 5 = 2 ∗ 2 + 1 , 2 = 1 ∗ 2 + 0 , 1 = 0 ∗ 2 + 1 (poids f ort)
10011011012 → 0010 0110 1101 → 26B16
2.1.1 Propriété remarquable
n−1 n−1
X an − 1 X
ai = et 2i = 2n − 1
a−1
i=0 i=0
En effet (an−1 + an−2 + ... + a1 + 1)(a − 1) = n
(a − an−1 + an−1 − an−2 . . . + a − 1) = (an − 1))
L’entier dont la représentation est constituée de n bits à 1 est 2n − 1 : 111111112 = 28 − 1 = 25510
2.1.2 Compléments à 1 et à 2
Soit E = n−1 i
P
i=0 ei ∗ 2 un entier naturel représenté sur n chiffres en base
Pn 2. On appelle complément
n
à 2 − 1 de E (on dit habituellement complément à 1 de E) l’entier E = i=0 ei obtenu en remplaçant
les 1 par des 0 et les 0 parP 1 − ei ) dans la représentation
des 1 (ei = P en binaire de E. Il s’écrit ˜E en
langage C. On a E + E = ni=0 ei 2i + ni=0 (1 − ei )2i = i=0
Pn−1 i
2 = 2n − 1, d’où E = 2n − 1 − E.
On appelle complément à 2n de E (on dit habituellement complément à deux) l’entier naturel

2 2
2n − E, noté E . Par définition, E = E + 1. Soit u la position du premier un 2 dans la représentation
2
en binaire de E. La représentation de E est obtenue à partir de celle de E en inversant les n − u bits
de poids forts et en conservant les u bits de poids faibles.
2.2 Addition
On rappelle le principe de calcul dans l’addition : colonne par colonne, de droite à gauche. Les
retenues, habituellement placées au dessus de l’opérande gauche, sont placées ici en dessous de
l’opérande droit. Dans chaque colonne, on fait la somme des chiffres du premier (ai ) et du deuxième
(bi ) opérande, ainsi que la retenue entrante (ci ).
Le chiffre (ri ) du résultat est égal à :

— cette somme, la retenue sortante (ci+1 ) étant 0, si somme < base,
— cette somme moins la base, la retenue sortante (ci+1 ) étant 1, si somme ≥ base.
a3 a2 a1 a0 opérande gauche ai
+base b3 b2 b1 b0 opérande droit bi
C = c4 c3 c2 c1 c0 retenues sortante ci+1 ci entrante
r3 r2 r1 r0 résultat apparent ri
3 6 4 3 3 6 4 3
+10 5 7 8 5 5 7 8 5
C=0 1 1 0 0 C=0 1 ←1 1 ←1 0 ←0 0
9 4 2 8 9 < 10 9 14 ≥ 10 4 12 ≥ 10 2 8 < 10 8
0 1 1 1 0 1 1 1
+2 0 1 1 0 0 1 1 0
C=0 1 1 0 0 C=0 1 ←1 1 ←1 0 ←0 0
1 1 0 1 1< 2 1 3≥ 2 1 2≥ 2 0 1<2 1
2. ∀i, ei = 1 ⇒ i ≥ u, (u=0 si E=0)
Equipe
Dans une addition normale, la retenue entrante initiale (c0 , colonne de droite) est nulle. L’utilisa-
tion d’une retenue initiale à 1 permet de calculer l’expression opgauche + opdroit + 1 (pour réaliser des
soustractions par addition du complément à deux).
1 1 0 1 1 1 0 1
+2 1 0 0 1 1 0 0 1
C=1 0 0 1 1 C=1 0 ←0 0 ←0 1 ←1 1
0 1 1 1 2≥ 2 0 1< 2 1 1< 2 1 3≥2 1
0 1 0 0 0 1 0 0
+2 1 0 1 0 1 0 1 0
C=0 0 0 0 1 C=0 0 ←0 0 ←0 0 ←0 1
1 1 1 1 1< 2 1 1< 2 1 1< 2 1 1<2 1
2.3 Conventions d’interprétation (entiers naturels et relatifs)

Pi=n−2 i
Soit e = i=0 ei 2 . Sur n bits, on peut coder 2n valeurs différentes. Mais l’interprétation de ce
codage n’est pas unique. En pratique, l’entier écrit en−1 en−2 en−3 . . . e1 e0 en base deux représente
la valeur E = αen−1 2n−1 + e.
Les règles de calcul pour l’addition et la soustraction sont les mêmes quel que soit α : seule
l’interprétation des valeurs des opérandes et du résultat change.
Pi=n−1
2.3.1 Pour entiers naturels (N) : α = 1 et E = i=0 ei 2i .
En pratique, il n’est pas rare que les entiers manipulés dans la vie courante sortent de l’intervalle
de valeurs représentables dans les formats inférieurs à 64 bits. A titre d’exemple, les capitalisations
boursières des sociétés ne sont pas toutes représentables sur 32 bits.
Pour stocker une valeur entière toujours positive ou nulle 3 , le programmeur peut décider
d’utiliser une variable entière en interprétant son contenu comme un entier naturel (attribut unsi-
gned de type entier en langage C) afin de maximiser l’intervalle de valeurs représentables : [0 . . . 2n −1].
Le bit de poids fort n’a pas de signification particulière : il indique simplement si la valeur
représentée est supérieure à 2n−1 ou pas.
Dans le langage C, le type entier naturel est spécifié avec l’attribut unsigned, ou les types entier
naturel de taille précise uintxx t (x ∈ {8, 16, 32, 64} ) définis dans stdint.h (révisions récentes du
langage).
La figure en cercle 2.1 illustre les 24 = 16 codes binaires possibles sur 4 bits (incluses dans le
cercle intérieur) et (sur la couronne extérieure,en décimal) les valeurs d’entiers naturels représentées.
Chaque entier correspond à un angle de rotation depuis l’origine dans le sens trigonométrique 4 .
L’addition de 2 entiers peut être interprétée comme la sommation des angles de rotation des
opérandes. A partir d’un tour complet, il y a débordement (résultat apparent obtenu modulo 24 et
C=1 qui indique qu’il faudrait un bit de plus (à 1) pour représenter le vrai résultat).
3. Les constantes adresse et les variables pointeurs entrent dans cette catégorie.
4. ou anti-horaire
Equipe
12 11
13 −4 −5 10
−3 −6
1100 1011
14 1101 1010 9
−2 −7
1110
−
1001
15 −1 8
1111 1000 −8
0000 0111
0 +0 +7 7
0001 0110
+1
+
0101 +6
1 0010 6
0011 0100
+2 +5
2 +3 +4 5
3 4
Figure 2.1 – Représentation d’entiers naturels et signés sur 4 bits
2.3.2 Une convention à oublier : signe et valeur absolue

La convention la plus intuitive pour l’ensemble Z est de coder le signe dans le bit de poids fort
(0 : ≥ 0, 1 : ≤ 0) et la valeur absolue sur les n-1 bits de poids faibles.
Elle présente deux inconvénients majeurs pour le codage des entiers 5 :

— La valeur 0 a deux codages (sur 4 bits : 0000 et 1000)
— l’addition des relatifs est traitée différemment de celle des naturels
C’est pourquoi les entiers relatifs sont codés selon la méthode du complément à 2.
2.3.3 Pour entiers relatifs (Z) par la méthode du complément à 2 : α = −1 et

E = −en−1 2n−1 + i=n−2 ei 2i .
P
i=0
Le bit de poids fort représente maintenant le signe de l’entier et le principe consiste à retrancher
2n à la valeur associée aux entiers dont le bit de poids fort est à 1. Cette convention représente les
entiers négatifs selon la technique du complément à deux 6 : l’entier relatif -x est représenté comme
l’entier naturel 2n − x. Dans les langages, cette convention d’interprétation est généralement utilisée
par défaut (type entier sans attribut unsigned ou type intxx t en langage C).
Un entier relatif E dont le bit de signe est 0 (≥ 0) appartient à l’intervalle [0 . . . 2n−1 − 1] et sa

valeur associée est la même que dans la convention pour entier naturels.
5. elle est utilisée dans certains formats de représentation des nombres à virgule flottante
6. La convention alternative ”signe et valeur absolue” (resp. codé dans le bit de poids fort et codée sur les n-1 bits de
poids faibles) a l’inconvénient de définir deux zéros : +0 et -0. Rarement utilisée pour les entiers, elle peut s’appliquer à
la représentation des nombres à virgule flottante.
Equipe
Un entier E dont le bit de signe est 1 (< 0) appartient à l’intervalle [−2n−1 , +2n−1 − 1] et sa
valeur associée est −e2 = −(2n − e).
— Pour calculer l’opposé d’un entier, il faut prendre le complément à deux de cet entier (et non
inverser simplement le bit de signe).
— Sur n bits, l’entier −2n−1 est son propre complément à deux et l’entier relatif +2n−1 n’est pas
représentable.
— L’ajout d’un bit à 0 en poids fort d’un entier relatif négatif inverse son signe et change sa valeur.
La couronne intérieure de la figure 2.1 illustre le codage des entiers relatifs sur 4 bits. A chaque
entier peut être associé un angle de rotation dans le sens trigonométrique pour les entiers positifs ou
nuls et dans le sens horaire pour les entiers négatifs.
Le code 1001 peut représenter selon la convention d’interprétation soit l’entier naturel 9 soit
l’entier relatif -7. De même, 0101 est le code commun aux entiers naturels 5 et relatif +5.
L’addition de deux entiers relatifs de même signe donne une erreur lorsque la somme des angles
correspondant aux entiers va au-delà d’une rotation d’un demi-tour, avec un résultat apparent de
signe opposé à celui des opérandes. Cette erreur vient du fait que le résultat attendu n’appartient pas
à l’intervalle des valeurs représentables sur le nombre de bits de codage utilisé.
2.3.4 Intervalles représentables

n Convention naturels Convention relatifs
n 0 à 2n − 1 −2n−1 à +2n−1 − 1
8 0 à 255 -128 à +127
16 0 à 65535 (64Kb -1) -32768 (-32Kb ) à +32767 (32Kb -1)
32 0 à 4294967295 (4Gb -1) -2147483648 (-2Gb ) à +2147483647 (2Gb -1)
64 0 à 1, 8 × 1019 (16Eb − 1) −9 × 1018 (−4Eb ) à +9 × 1018 (+4Eb − 1)
Pour les bornes de l’intervalle sur 64 bits, le tableau mentionne l’ordre de grandeur (préfixé par) :
la valeur exacte représente une vingtaine de chiffres. Les préfixes Kb (kilo) et Mb (méga) représentent
210 = 102410 et 220 = 104857610 , dont la valeur est proche de 1000 (1K) et 1000000 (1M). Même
principe pour Gb (giga : 230 ) et Eb (eta : 260 ).
2.4 Changement de format, manipulation booléenne des bits,

décalages
2.4.1 Extension et réduction de format
Des conversions de taille sont nécessaires lors de la copie d’un entier entre 2 contenants de tailles
différentes, par exemple un registre de 32 bits et un emplacement mémoire de 8 ou 16 bits.
La réduction de format élimine les bits de poids forts excédentaires (opération modulo). La valeur
entière n’est pas modifiée si elle est représentable sur le contenant de plus petite taille.
En sens inverse, la représentation de l’entier doit être étendue en ajoutant des bits de poids forts
selon la nature de l’entier :
Equipe
— ajout de bits à 0 pour un entier naturel
— duplication de l’ancien bit de poids fort (bit de signe) pour un entier relatif
Il existe ainsi 3 instructions ARM de transfert d’un entier entre un registre 32 bits regx et un
emplacement de 16 bits en mémoire mem[y]. L’instruction ldrh est destinée aux entiers naturels codés
sur 16 bits, et ldrsh aux entiers relatifs.
— strh : regx modulo 216 → mem[y]
— ldrh : regx extension en ajoutant 16 f ois un bit 0 mem[y]
←−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
— ldrsh : regx extension en ajoutant 16 f ois le bit de poids f ort de mem[y]
←−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
2.4.2 Décalage et rotation

Le décalage logique à gauche de k bits (Logic Shift Left #k en langage d’assemblage ARM, k
en C) d’un entier e ajoute d bits à 0 à droite, ce qui revient à multiplier e par 2d . Le format de
représentation restant inchangé, le décalage supprime les k bits de poids forts de e. Si l’un de ces bits
éjectés n’est pas 0, le résultat de la multiplication n’est pas représentable sur le nombre de bits utilisé.
Remarque : l’entier 2k est l’entier 1 décalé de k bits à gauche (((uint32 t)1 k) en C).
Une opération de rotation est un décalage dans lequel les bits ajoutés à une extrémité sont ceux
qui sont éjectés de l’autre extrémité de l’entier. Une rotation à gauche de k bits et une rotation à
droite de n − k bits ont le même effet.
Le décalage de k bits à droite correspond à la division par 2k : les k bits de poids faibles sont éjectés.
Le décalage logique de k bits à droite (Logic Shift Right #k en langage d’assemblage ARM, k
sur une variable unsigned en C) est destiné aux entiers naturels : k bits à 0 sont ajoutés en poids
forts et l’entier est divisé par 2k .
Le décalage arithmétique à droite (Arithmetic Shift Right en langage d’assemblage ARM) est
destiné aux entiers relatifs : le bit de poids fort (signe) d’origine est recopié dans les bits ajoutés à
gauche. L’entier est divisé par 2k s’il en était un multiple au départ.
2.4.3 Opérations booléennes bit à bit

Un chiffre de la base 2 (bit d’un entier) et un booléen ont la même écriture : 0 ou 1.
Les opérateurs bit à bit traitent un entier sur n bits comme une collection de n booléens : chaque
bit de rang j du résultat correspond à une opération booléenne sur les bits de rang j des opérandes.
La négation (un seul opérande) bit à bit (˜ en C) inverse tous les bits de l’entier : elle réalise le
complément à 1 de celui-ci.
Les autres opérations booléennes classiques à 2 deux opérandes existent aussi en version bit à bit :
— Et bit à bit (& en C)
— Ou bit à bit (— en C)
— Ou exclusif bit à bit (ˆ en C, remarquer que ce n’est pas l’opérateur d’élévation à la puissance)
Noter la différence avec les opérateurs booléens classiques du C :

— 11 && 13 donne 1 (11 6= 0) : vrai, 13 6= 0 : vrai, vrai et vrai : vrai → 1
— 11 & 13 donne 9 : seuls les bits 0 et 3 sont à 1 dans les deux entiers.
Equipe
2.4.4 Exemples d’application
Tous les entiers des exemples suivant sont supposés déclarés de type unsigned.
Tester si le bit b de e est à 1 (3 méthodes différentes) :

— décaler une copie de e de b bits à droite, puis ET bit à bit avec 20 = 1 : si 6= 0, le bit à tester
est 1 ou
— décaler une copie de e pour amener le bit b en poids fort : le résultat interprété comme un
entier relatif est < 0 si le bit b de e est à 1 ou
— ET bit à bit entre e et 1 décalé à gauche de b bits : bit testé à 1 si résultat non nul
Création de masque : entier dont les bits x à y (y ≥ x) inclus sont à 0, les autres à 1 (utilisé dans
un ET bit à bit, permet de forcer à 0 les bits x à y d’un entier) :
1. Complément à 1 de 0 (˜0) : entier composé uniquement de bits à 1

2. décalage à gauche pour supprimer les bits à 1 au-delà du rang y
3. décalage à droite pour supprimer les bits à 1 en deçà du rang x
4. décalage à gauche pour ramener le premier bit à 1 au rang x
5. complément à 1 : inversion de tous les bits
2.5 Soustraction
Dans chaque colonne, on fait la somme du chiffre du deuxième (bi ) opérande et de l’emprunt
entrant (ei ) et l’emprunt entrant initial e0 est nul. Le chiffre (ri ) du résultat est égal :
— au chiffre du premier opérande (ai ) moins cette somme, l’emprunt sortant (ei+1 ) étant 0, si
somme ≤ ai ,
— au chiffre du premier opérande (ai ) plus la base moins cette somme, l’emprunt sortant (ei+1 )
étant 1, si somme > ai ,
a3 a2 a1 a0 opérande gauche ai
+base b3 b2 b1 b0 opérande droit bi
E = e4 e3 e2 e1 e0 emprunts sortant ei+1 ei entrant
r3 r2 r1 r0 résultat apparent ri
8 6 4 8 8 6 4 8
−10 5 7 9 5 5 7 9 5
E=0 1 1 0 0 E=0 1 ←1 1 ←1 0 ←0 0
2 8 5 3 6≤8 2 8>6 8 9>4 5 5≤8 3
1 1 0 1 1 1 0 1
−2 0 1 1 0 0 1 1 0
E=0 1 1 0 0 E=0 1 ←1 1 ←1 0 ←0 0
0 1 1 1 0≤1 0 2>1 1 1>0 1 0≤1 1
0 1 0 0 0 1 0 0
−2 0 1 0 1 0 1 0 1
E=1 1 1 1 0 E=1 1 ←1 1 ←1 1 ←1 0
1 1 1 1 1>0 0 2>1 1 1>0 1 1>0 1
Equipe
2.6 Soustraction par addition du complément à deux
En pratique, toutes les soustractions sont réalisées par addition du complément à 2. On exploite
la propriété suivante (calculs sur n bits) : x + y 2 = x + 2n − y.
Les résultats étant obtenus modulo 2n , on peut calculer l’expression x−y en effectuant une addition
comme suit :
— Premier opérande : x
— Deuxième opérande : y
— Retenue initiale : 1 (pour faire x + y + 1)
— On observe que la ligne des retenues dans cette addition de y est le complément de la ligne des
emprunts dans la soustraction normale.
Le calcul de 13 − 6 (réalisable) et 4 − 5 (impossible pour des entiers naturels) est illustré par les
deux derniers exemples des paragraphes 2.5 (soustraction normale) et 2.2 (soustraction par addition
du complément à deux).
2.7 Indicateurs et débordements

Lors d’une opération (addition ou soustraction) sur les entiers, l’unité de calcul d’un processeur
synthétise quatre indicateurs booléens à partir desquels il est possible de prendre des décisions.
2.7.1 Nullité et indicateur : Z

L’indicateur Z (Zéro) et vrai si et seulement tous les bits du résultat apparent sont à 0, ce qui
signifie que ce dernier est nul.
2.7.2 Signe du résultat apparent : N

L’indicateur N est égal au bit de poids fort du résultat apparent. Si ce dernier est interprété comme
un entier relatif, N=1 signifie que le résultat apparent est négatif.
2.7.3 Débordement en convention d’entiers naturels : C

L’indicateur C (Carry) est la dernière retenue sortante de l’addition. Il n’a de sens que dans une
interprétation de l’opération sur des entiers naturels.
Après une addition, C = 1 indique un débordement : le résultat de l’opération est trop grand
pour être représentable sur n bits. Le résultat apparent est alors faux : il correspond au vrai résultat
à 2n près.
E est le dernier emprunt sortant d’une soustraction. E = 1 indique que la soustraction est im-
possible parce que le deuxième opérande est supérieur au premier. Les soustractions sont en pratique
réalisées par addition du complément à deux. C correspond alors à E. Après une soustraction par
addition du complément à deux, C = 0 indique que la soustraction est impossible, C = 1 que
l’opération est correcte 7 .
7. Attention : les instructions de soustraction ou de comparaison de certains processeurs (dont le SPARC) stockent
dans C le complément de la retenue finale. Pour ces processeurs, C = 1 indique toujours une erreur, que ce soit après
une addition ou une soustraction.
Equipe
2.7.4 Débordement en convention d’entiers relatifs : V
Pour les entiers, la soustraction est toujours réalisée par addition de l’opposé du deuxième opérande.
La valeur absolue de la somme de deux entiers relatifs de signes opposés est inférieure ou égale à la
la plus grande des valeurs absolues des opérandes et le résultat est toujours représentable sur n bits.
La somme de deux entiers relatifs de même signe peut ne pas être représentable sur n bits, auquel cas
le résultat apparent sera faux :
— Sa valeur n’est égale à celle du vrai résultat de l’opération qu’à 2n près.
— Son bit de signe (bit de poids fort) est également faux : la somme de deux entiers positifs
donnera un résultat apparent négatif et la somme de deux entiers négatifs donnera un résultat
apparent positif ou nul.
L’indicateur V (oVerflow 8 ) est l’indicateur de débordement destiné à la convention d’in-

terprétation pour entiers relatifs. V = 1 indique un débordement, auquel cas les deux dernières
retenues sont de valeurs différentes.
0 0 1 1 +3 0 1 1 0 +6
+2 1 0 1 1 -5 +2 0 1 0 0 +4
V=0 0=0 1 1 0 V=1 6 1
0= 0 0 0
1 1 1 0 -2 1 0 1 0 -6
1 0 1 0 -6
+2 1 1 0 0 -4
V=1 1 6= 0 0 0 0
0 1 1 0 +6
Le signe du vrai résultat (sans erreur) de l’opération s’écrit : V ⊕ N = V .N + V.N . Ainsi, le signe
du résultat de l’opération sans erreur est N signe du résultat apparent s’il n’y a pas de débordement
(V ), ou le signe opposé N de celui du résultat apparent en cas de débordement (V ).
2.7.5 Expressions des conditions avec les indicateurs ZNCV

Après synthèse des indicateurs lors du calcul de x − y, il est possible de tester diverses conditions.
Par exemple ,l’expression de la condition ”strictement inférieur” (x < y) est :

— C si x et y sont considérés comme des entiers naturels (la soustraction est impossible)
— V ⊕ N si x et y sont considérés comme des entiers relatifs (le vrai résultat est négatif).
2.8 Exercices
2.8.1 Addition d’entiers naturels
Quels entiers naturels peut-on représenter sur 4 bits ?
Choisir deux entiers naturels représentables sur 4 bits, faire la somme en faisant apparaı̂tre les
retenues propagées. Quand la somme n’est-elle pas représentable sur 4 bits ?
On pourra reprendre l’exercice pour des nombres représentés sur 8, 16 ou 32 bits...
2.8.2 Représentation des entiers relatifs en complément à deux

Quels entiers relatifs peut-on représenter sur 4 bits ? Donner pour chacun leur codage en
complément à 2.
8. L’initiale O n’a pas été retenue pour éviter une confusion avec zéro
Equipe
Quels entiers relatifs peut-on représenter sur 8 bits ? Comment s’y prendre pour coder un entier
relatif en complément à 2 sur 8 bits ? Comment passer d’un relatif négatif à son opposé ?
Choisir un entier relatif positif représentable sur 4 bits. Donnez sa représentation sur 8 bits.
Choisir un entier relatif négatif représentable sur 4 bits. Donnez sa représentation sur 8 bits.
2.8.3 Addition d’entiers relatifs

Choisir deux entiers relatifs un positif et un négatif représentables sur 4 bits, faire la somme. Quand
la somme n’est-elle pas représentable sur 4 bits ?
Choisir deux entiers relatifs positifs représentables sur 4 bits, faire la somme. Identifier les cas où
la somme n’est pas représentable sur 4 bits ?
Même question pour deux entiers relatifs négatifs.
On pourra reprendre les exercices pour des nombres représentés sur 8, 16 ou 32 bits...
2.8.4 Soustraction de naturels

Choisir deux entiers naturels représentables sur 4 bits, faire la différence. Quand la différence
n’est-elle pas représentable sur 4 bits ?
Pour comparer deux nombres a et b on peut calculer la différence a − b ; a > b ssi a − b > 0.
Dans le tableau de la figure 2.2 de votre documentation retrouvez les lignes correspondant à des
comparaisons (>, <, ≤, ≥) de nombres dans N. Faire le lien avec la réponse que vous avez donnée
précédemment.
2.8.5 Comparaisons d’entiers relatifs

Choisir deux entiers relatifs représentables sur 4 bits, faire la différence. Exprimer quand la
différence n’est pas représentable est un peu plus complexe : on trouve les expressions logiques
nécessaire dans le tableau de la figure 2.2 de votre documentation. Prendre un exemple par
exemple le cas ≤ et chercher des entiers relatifs correspondant à chacun des cas de l’expression
Z ∨ ((N ∧ V ) ∨ (N ∧ V )).
2.8.6 Multiplier et diviser par une puissance de deux

Choisir un entier naturel n représentable sur 8 bits. Quelle est la représentation de 2 ∗ n, de 4 ∗ n,
de 8 ∗ n ? Quelle est la représentation de n/2, de n/4, de n/8 ?
Choisir un entier relatif (essayer avec un positif puis avec un négatif) x représentable sur 8 bits.
Quelle est la représentation de 2 ∗ x, de 4 ∗ x, de 8 ∗ x ? Quelle est la représentation de x/2, de x/4,
de x/8 ?
Equipe
Chapitre 3
TD séance 3 : Langage machine,

codage des données
3.1 Sujet du TD
On considère l’instruction : x := (a + b + c) - (x - a - 214).
x, a, b et c sont des variables représentées sur 32 bits et rangées en mémoire aux adresses (fixées
arbitrairement) : 0x50f0 0x2fa0, 0x3804, 0x4050.
Il existe un espace mémoire libre à partir de l’adresse 0x6400.
On veut écrire un programme en langage machine qui exécute l’instruction considérée. Le pro-
gramme ne doit pas changer les valeurs des variables a, b et c (i.e. ne doit pas changer le contenu des
cases mémoire correspondantes).
Exercice : Dans chacun des langages machines décrits dans la suite, écrire systématiquement le
programme qui exécute l’instruction ci-dessus.
3.2 Un premier style de langage machine : machine dite à accumu-

lateur
La figure 3.1 donne la structure de la machine. Cette machine possède un registre spécial appelé
accumulateur (on notera ACC) utilisé dans les opérations à la fois comme un des deux opérandes et
pour stocker le résultat.
Dans une telle machine une instruction de calcul est formée du code de l’opération à réaliser
(addition ou soustraction) et de la désignation d’un opérande. Il y a deux façons de désigner une
information : on donne son adresse en mémoire ou on donne une valeur.
instruction opération réalisée
add adr ACC <-- ACC + MEM[adr]
add# vi ACC <-- ACC + vi
sub adr ACC <-- ACC - MEM[adr]
sub# vi ACC <-- ACC - vi
Par ailleurs, on peut aussi charger une information dans l’accumulateur depuis la mémoire ou avec
une valeur appelée valeur immédiate.
load adr ACC <-- MEM[adr]
load# vi ACC <-- vi
Equipe
BUS DONNEES
0x0000
opérande
instructions
UAL
registre
instruction
ACC BUS ADRESSES 0x2fa0 valeur de a
0x3804 valeur de b
0x4050 valeur de c données
PROCESSEUR 0x50f0 valeur de x
0x6400 libre
si besoin
0xffff
MEMOIRE
Figure 3.1 – Structure d’une machine à accumulateur
Et enfin, on peut ranger la valeur contenue dans l’accumulateur en mémoire :

store adr MEM[adr] <-- ACC
1. Calculer la taille du programme si on suppose que les adresses sont représentées sur 16 bits (2
octets), les valeurs immédiates sont aussi représentées sur 2 octets et le code instruction est lui
codé sur 1 octet.
2. Quelle est la différence entre sub 0x2fa0 et sub# 214 ?
3. Une instruction store# 6 a-t-elle une signification ?
4. Ecrire un programme qui réalise le même calcul en commençant par évaluer la soustraction.
Les microprocesseurs des années 70/80 ressemblent à ce type de machine : type 6800, 6501 (APPLE
2), Z80. Il en existe encore dans les petits automatismes, les cartes à puce, ... Les adresses sont souvent
sur 16 bits, les instructions sur 1,2,3,4 octets, le code opération sur 1 octet.
3.3 Machine avec instructions à plusieurs opérandes

On va s’intéresser maintenant à une machine dans laquelle on indique dans l’instruction : le code
de l’opération à réaliser, un opérande dit destination et deux opérandes source.
On pourrait imaginer une instruction de la forme : add adr1, adr2, adr3 dont la signification
serait : mem[adr1] <-- mem[adr2] + mem[adr3].
Cela coûterait cher en taille de codage d’une instruction (6 octets pour les adresses si une adresse
est sur 2 octets + le reste) mais surtout en temps d’exécution d’une instruction (3 accès mémoire).
Dans ce type de machine, il y a en fait des registres, proches du processeur et du coup d’accès plus
rapide. On peut y stocker les informations avec lesquelles sont faits les calculs (Cf. figure 3.2). Il y a
de plus des opérations de transfert d’information de la mémoire vers les registres (et inversement).
Les registres sont repérés par des numéros. On note reg5 le registre de numéro 5 par exemple. On
notera aussi reg5 la valeur contenue dans le registre.
Equipe
BUS DONNEES
0x0000
opérande1 opérande2 registre
instruction
instructions
UAL
R0
R1
opérande_dest R2 BUS ADRESSES 0x2fa0 valeur de a
0x3804 valeur de b
0x4050 valeur de c données
PROCESSEUR 0x50f0 valeur de x
0x6400 libre
si besoin
0xffff
MEMOIRE
Figure 3.2 – Structure d’une machine générale à registres
Une instruction de calcul est formée du code de l’opération à réaliser, et de la désignation des
registres intervenant dans le calcul. On trouve deux formes de telles instructions :
— deux opérandes sources dans des registres (on écrira regs1 et regs2) et un registre pour le
résultat du calcul (on écrira regd pour registre destination).
— un opérande source dans un registre et l’autre donné dans l’instruction (valeur immédiate) et
toujours un registre destination.

add regd regs1 regs2 regd <-- regs1 + regs2
sub regd regs1 regs2 regd <-- regs1 - regs2
add# regd regs1 vi regd <-- regs1 + vi
sub# regd regs1 vi regd <-- regs1 - vi
Au niveau du codage, il faut coder : le code de l’opération à réaliser et les numéros des registres.
Par exemple sur ARM il y a 16 registres, d’où 4 bits pour coder leur numéro.
Nous avons besoin aussi d’effectuer des transferts entre mémoire et registres. En général, dans ce
genre de machine les adresses (et les données) sont représentées sur 32 bits (question d’époque...).
Le problème est que pour représenter l’instruction amener le mot mémoire d’adresse 0x2fa0 dans le
registre 2, il faut : 1 codeop + 1 numéro de registre sur x bits + 1 adresse (0x2fa0) sur 32 bits pour
former l’instruction... codée elle aussi sur 32 bits.
Les opérations de transfert sont réalisées en deux étapes : mettre l’adresse du mot mémoire concerné
dans un registre (ci-dessous reg1) puis charger un registre avec le contenu du mot mémoire à cette
adresse (load) ou ranger le contenu du mot mémoire à cette adresse dans un registre (store).

METTRE reg1, adr reg1 <-- adr
load reg2, [reg1] reg2 <-- Mem[reg1]
ou
METTRE reg1, adr reg1 <-- adr
store [reg1], reg2 Mem[reg1] <-- reg2
Equipe
1. Si on suppose qu’une instruction est codée sur 4 octets, quelle est la taille du programme ?
2. Discuter de la taille de codage des numéros de registres.
3. Discuter de la taille de codage des valeurs immédiates.
4. Pourquoi en général n’y a-t-il qu’une valeur immédiate ?
Les microprocesseurs des années 90 sont de ce type : machines RISC, type Sparc, ARM. Les
adresses sont en général sur 32 bits, toutes les instructions sont codées sur 32 bits, et il y a beaucoup
de registres.
Remarque : Attention, pour le processeur ARM, dans la syntaxe de l’instruction store les
opérandes sont inversés par rapport au choix fait ci-dessus ; on écrit str reg2, [reg1]. Ainsi l’ordre
d’écriture des opérandes est le même pour l’instruction store (str) et l’instruction load (ldr).
Dans les années 70/80 il y a eu des processeurs (pas micro du tout) de type VAX (inspirés de,
avec beaucoup de variantes). Une instruction peut être codée sur 4 mots de 32 bits et donc contenir
3 adresses.
Il a été construit dans les années 80/90 des microprocesseurs avec deux opérandes pour une ins-
truction : un opérande source servant aussi de destination (type 68000, 8086). Les adresses sont sur
16, 24 ou 32 bits, les instructions sur 1,2,3 ou 4 mots de 16 bits. Le code opération est généralement
sur 1 mot de 16 bits. Il y a 8 ou 16 registres.
3.4 Codage de METTRE ?

Il reste à comprendre comment coder : METTRE une adresse de 32 bits dans un registre ?
Même si on n’a plus que le code de METTRE, un seul numéro de registre, l’adresse reste sur 32
bits et ça ne tient toujours pas...
Par exemple, on veut coder : charger reg2 avec le mot mémoire d’adresse 0x2fff2765. On
va donc coder : METTRE reg1, 0x2fff2765 puis load reg2, [reg1].
Equipe
Chapitre 4
TD séance 4 : Codage des données

(suite)
4.1 Données en mémoire

(suite/rappel) On travaille sur un programme écrit en langage d’assemblage ARM qui exécute l’ins-
truction : x := (a + b + c) - (x - a - 214).
Dans la pratique, ce n’est pas nous qui fixons les adresses, elles sont fixées par les outils de tra-
duction et/ou de chargement en mémoire et nous on peut utiliser des étiquettes... c’est plus agréable
à lire.
Le programme ARM :
@ programme calculant x <-- (a + b + c) + - (x - a - 214)
.text
.global main
main: ldr r1, ptr_a
ldr r1, [r1]
ldr r2, ptr_b
ldr r2, [r2]
ldr r3, ptr_c
ldr r3, [r3]
add r4, r1, r2
add r4, r4, r3
ldr r2, ptr_x
ldr r3, [r2]
sub r3, r3, r1
sub r3, r3, #214
sub r4, r4, r3
str r4, [r2]
mov pc, lr
.org 0x1000
ptr_a: .word a
ptr_b: .word b
ptr_c: .word c
ptr_x: .word x
.data
.org 0x2fa0
a: .word 10
.org 0x3804
b: .word 20
.org 0x4050
c: .word 30
.org 0x50f0
x: .word 1000
Equipe
La directive .org permet de fixer l’adresse relative où sera stockée la valeur qui suit. Par exemple,
le mot étiquetté a sera rangé à l’adresse de début de la zone data + 0x2fa0.
1. Dessiner le contenu de la zone de données en exprimant les valeurs des différentes données en
hexadécimal (en faisant apparaı̂tre les différents octets).
2. Ajouter des commentaires au programme explicitant chacune des lignes de code.
On traduit le programme en binaire en fixant les adresses de début de la zone text et de la zone
data :
arm-eabi-as -o exp_arm.o exp_arm.s -mbig-endian

arm-eabi-ld -o exp_arm exp_arm.o -e main -Ttext 0x800000 -Tdata 0x0 -EB
La zone text étant stockée à partir de l’adresse 0x800000 (option -Ttext 00800000) et la zone
data à partir de l’adresse 00000000 (option -Tdata 0x0), on regarde la traduction obtenue.
Zone text :
$ arm-eabi-objdump -d -j .text exp_arm
exp_arm: file format elf32-bigarm
Disassembly of section .text:
00800000 <main>:
800000: e59f1ff8 ldr r1, [pc, #4088] ; 801000 <ptr_a>
800004: e5911000 ldr r1, [r1]
800008: e59f2ff4 ldr r2, [pc, #4084] ; 801004 <ptr_b>
80000c: e5922000 ldr r2, [r2]
800010: e59f3ff0 ldr r3, [pc, #4080] ; 801008 <ptr_c>
800014: e5933000 ldr r3, [r3]
800018: e0814002 add r4, r1, r2
80001c: e0844003 add r4, r4, r3
800020: e59f2fe4 ldr r2, [pc, #4068] ; 80100c <ptr_x>
800024: e5923000 ldr r3, [r2]
800028: e0433001 sub r3, r3, r1
80002c: e24330d6 sub r3, r3, #214 ; 0xd6
800030: e0444003 sub r4, r4, r3
800034: e5824000 str r4, [r2]
800038: e1a0f00e mov pc, lr
...
00801000 <ptr_a>:
801000: 00002fa0 andeq r2, r0, r0, lsr #31
00801004 <ptr_b>:
801004: 00003804 andeq r3, r0, r4, lsl #16
00801008 <ptr_c>:
801008: 00004050 andeq r4, r0, r0, asr r0
0080100c <ptr_x>:
80100c: 000050f0 streqd r5, [r0], -r0
Zone data :
$ arm-eabi-objdump -s -j .data exp_arm
exp_arm: file format elf32-bigarm
Contents of section .data:

0000 00000000 00000000 00000000 00000000 ................
...
2f90 00000000 00000000 00000000 00000000 ................
2fa0 0000000a 00000000 00000000 00000000 ................
2fb0 00000000 00000000 00000000 00000000 ................
Equipe
...
2fc0 00000000 00000000 00000000 00000000 ................
...
37f0 00000000 00000000 00000000 00000000 ................
3800 00000000 00000014 00000000 00000000 ................
3810 00000000 00000000 00000000 00000000 ................
...
4040 00000000 00000000 00000000 00000000 ................
4050 0000001e 00000000 00000000 00000000 ................
4060 00000000 00000000 00000000 00000000 ................
...
4070 00000000 00000000 00000000 00000000 ................
...
50e0 00000000 00000000 00000000 00000000 ................
50f0 000003e8 ....
1. En fin de zone text on trouve le binaire correspondant aux déclarations des adresses en zone
data. Repérez les valeurs (attention : ce sont des adresses) associées aux étiquettes ptr a,
ptr b, ptr c et ptr x.
2. Retrouvez les valeurs rangées à ces adresses dans la zone data.
3. Quelle est la traduction de l’instruction ldr r1, ptr a ? Etudiez le codage binaire de cette
instruction et retrouvez-y les différents éléments : le code de ldr, le code des registres r1 et pc
et la valeur du déplacement.
4. Quelle est la traduction de l’instruction ldr r1, [r1] ? Etudiez le codage binaire de cette
instruction et retrouvez-y les différents éléments : le code de ldr, le code des registres r1 et r1
et la valeur du déplacement.
5. Comprendre le déplacement codé dans l’instruction ldr r1, ptr a ?
6. Recommencer le même travail avec l’instruction ldr r2, ptr x ?
Codage des instructions ldr et str : La figure 4.1 donne un sous-ensemble des règles de codage
des instructions ldr et str, suffisant pour traiter les exercices précédents. On peut par exemple coder :
ldr rd, [rn, +/-déplacement] ; le bit U code le signe du déplacement (1 pour +, 0 pour −) et le
bit L vaut 1 pour ldr et 0 pour str.
31 28 27 24 23 22 21 20 19 16 15 12 11 0
cond 0101 U 00 L rn rd deplacement
Figure 4.1 – Codage des instructions ldr et str
4.2 Codage des tableaux

Pour les chaines de caractères et les tableaux ”simples” (à 1 dimension), le placement en mémoire
est immédiat : à partir d’une adresse de départ qui est associée à la chaine de caractère, resp. au
tableau, les caractères, resp. les éléments de tableaux, sont disposés dans la mémoire à la suite. Pour
les caractères, octet après octet. Pour un tableau d’entiers 32 bits, chaque entier sera donc placé sur un
bloc de 4 octets en suivant la convention grand-boutiste (big-endian) ou petit-boutiste (little-endian)
adoptée.
1. Combien faudra-t-il de place pour placer la chaine de caractère ”Bonjour !” en mémoire (prendre
en compte le codage de fin de chaı̂ne par un 0).
Equipe
2. Si l’adresse de départ est multiple de 4, quelle sera la prochaine adresse multiple de 4 ? (en
déduire la place occupée en pratique).
3. Dessiner la mémoire obtenue pour placer la chaine de caractère ”Bonjour” à partir de l’adresse
0x8080
4. Dessiner la mémoire obtenue pour placer le tableau [0x12345678,0xAABBCCDD,0x0,0x1] à
partir de l’adresse 0xA000 (par exemple avec la convention grand-boutiste).
5. Quelles sont les valeurs du tableau vues par Bob si Bob pense que le tableau a été écrit avec la
convention petit-boutiste) ?
Pour les tableaux à 2 dimensions, c’est presque la même chose, il suffit de voir le tableau comme
un tableau à une dimension de tableaux à une dimension : soit un tableau de lignes, soit un tableau
de colonnes.
1. Dessiner la mémoire obtenue pour placer le tableau ci dessous comme tableau de lignes
2. Dessiner la mémoire obtenue pour placer le tableau ci dessous comme tableau de colonnes
3. Dans un tableau d’entiers (32 bits) de 100 lignes et 1000 colonnes quelle sera la distance (en
nombre d’octets) entre 2 éléments voisins sur une même ligne si la tableau a été placé en
mémoire en utilisant la disposition ”tableau de lignes”.
4. Même question pour la disposition ”tableau de colonnes”.
5. Idem pour 2 entiers voisins dans une même colonne pour les deux dispositions.
0x01020304 0x05060708 0x090A0B0C 0x0D0E0F10

0x11121304 0x15161718 0x191A1B1C 0x1D1E1F10
0x21222324 0x25262728 0x292A2B2C 0x2D2E2F10
Figure 4.2 – Tableau de nombres
Equipe
Chapitre 5
TD séances 5 et 6 : Codage des

structures de contrôle
5.1 Codage d’une instruction conditionnelle

On veut coder l’algorithme suivant : si a = b alors c <-- a-b sinon c <-- a+b.
L’évaluation de l’expression booléenne a = b est réalisée par une soustraction a-b dont le résultat
ne nous importe guère ; on veut juste savoir si le résultat est 0 ou non. Pour cela on va utiliser
l’indicateur Z du code de condition arithmétique positionné après une opération :
Z = 1 si et seulement si le résultat est nul
Z = 0 si et seulement si le résultat n’est pas nul.
De plus nous allons utiliser l’instruction de rupture de séquence Bcc qui peut être conditionnée
par les codes de conditions arithmétiques cc.
On peut proposer beaucoup de solutions dont les deux suivantes assez classiques :
@ a dans r0, b dans r1

CMP r0, r1 @ a-b ?? CMP r0, r1 @ a-b ??
BNE sinon BEQ alors
alors: @ a=b : c <-- a-b sinon: @ a!=b : c <-- a+b
BAL finsi BAL finsi
sinon: @ a!=b : c <-- a+b alors: @ a=b : c <-- a-b
finsi: finsi:
Exercices :
1. Comprendre l’évolution du contrôle (compteur de programme, valeur des codes de conditions
arithmétiques) pour chacune des deux solutions.
2. Quel est l’effet du programme suivant :
CMP r0, r1
BNE sinon
SUB r2, r0, r1
sinon: ADD r2, r0, r1
3. Coder en langage d’assemblage ARM l’algorithme suivant :
si x est pair alors x <-- x div 2 sinon x <-- 3 * x + 1
la valeur de la variable x étant rangée dans le registre r5.
Equipe
5.2 Notion de tableau et accès aux éléments d’un tableau
Considérons la déclaration de tableau suivante :
TAB : un tableau de 5 entiers représentés sur 32 bits.
Il s’agit d’un ensemble d’entiers stockés dans une zone de mémoire contiguë de taille 5 × 32 bits (ou
5 × 4 octets). La déclaration en langage d’assemblage d’une telle zone pourrait être :
debutTAB: .skip 5*4
où debutTAB représente l’adresse du premier élément du tableau (considéré comme l’élément numéro
0). debutTAB est aussi appelée adresse de début du tableau.
Quelle est l’adresse du 2eme élément de ce tableau ? du 3eme ? du ieme , 0 ≤ i ≤ 4 ?
On s’intéresse à l’algorithme suivant :
TAB[0] <-- 11
TAB[1] <-- 22
TAB[2] <-- 33
TAB[3] <-- 44
TAB[4] <-- 55
Les deux premières affectations peuvent se traduire :
.data
debutTAB: .skip 5*4
.text
.global main
main:
ldr r0, ptr_debutTAB
mov r1, #11
str r1, [r0]
mov r1, #22

add r0, r0, #4 @ *
str r1, [r0] @ *
@ a completer
fin: bal fin
ptr_debutTAB : .word debutTAB
A la place des lignes marquées (*) on peut écrire une des deux solutions suivantes :
— str r1, [r0, #4] ; le registre r0 n’est alors pas modifié.
— ou mov r2, #4 puis str r1, [r0, r2] ; le registre r0 n’est pas modifié.
Exercices : Compléter ce programme de façon à réaliser la dernière affectation. Reprendre le même

problème avec un tableau de mots de 16 bits. Reprendre le même problème avec un tableau d’octets.
5.3 Codage d’une itération

Si notre tableau était formé de 10000 éléments, la méthode précédente serait bien laborieuse . . . On
utilise alors un algorithme comportant une itération.
Equipe
lexique local :
i : un entier compris entre 0 et 4
val : un entier
algorithme :
val <-- 11
i parcourant 0..4
TAB[i] <- val
val <- val + 11
ce qui peut aussi s’écrire :
val <-- 11
i <-- 0
tant que i <> 5 @ ou bien : tant que i <= 4 ou encore i < 5
TAB[i] <- val
val <- val + 11
i <-- i + 1
A noter : si i était mal intialisé avant le tant que (par exemple i = 6), on obtiendrait une boucle
infinie avec le test 6=, et une terminaison sans exécuter le corps du tant que avec les conditions < ou ≤.
Nous exprimons le même algorithme en faisant apparaı̂tre explicitement l’adresse d’accès au mot
de la mémoire : TAB[i].
val <-- 11
i <-- 0
tant que i <> 5
MEM [debutTAB + 4*i] <-- val
val <- val + 11
i <-- i + 1
Exercices :
1. Coder cet algorithme en langage d’assemblage, en installant les variables val, i et debutTAB
respectivement dans les registres : r3, r2 et r0.
Pour évaluer l’expression booléenne i <> 5, on calcule i-5, ce qui nous permet de tester la
valeur de i <> 5 en utilisant l’indicateur Z code de condition arithmétique : si Z = 1, i-5 est
égal à 0 et si Z = 0, i-5 est différent de 0.
2. Dérouler l’exécution en donnant le contenu des registres à chaque itération.
3. Modifier le programme si le tableau est un tableau de mots de 16 bits ?
4. Lors de l’exécution du programme précédent on constate que la valeur contenue dans le registre
r0 reste la même durant tout le déroulement de l’exécution ; il s’agit d’un calcul constant de
la boucle. On va chercher à l’extraire de façon à ne pas le refaire à chaque fois. Pour cela on
introduit une variable AdElt qui contient à chaque itération l’adresse de l’élément accédé.
val <-- 11; i <-- 0
AdElt <- debutTAB
tant que i <= 4
{ invariant : AdElt = debutTAB + 4 * i }
MEM [AdElt] <-- val
i <-- i + 1
val <- val + 11
AdElt <- AdElt + 4
Equipe
On peut alors supprimer la variable d’itération i en modifiant le test d’arrêt de l’itération.
D’une boucle de parcours de tableau par indice on passe à une boucle de parcours par pointeur
(la variable indice i peut être supprimée) :
— multiplication des deux membres de l’inéquation par 4 : 4 ∗ i ≤ 4 ∗ 4
— ajout de debutTAB : debutT AB + 4 ∗ i ≤ debutT AB + 4 ∗ 4
— remplacement de debutTAB+4*i par AdElt
{ i = 0 }
val <-- 11; AdElt <- debutTAB; finTAB <- debutTAB+4*4
tant que AdElt <= finTAB
{ invariant : AdElt = debutTAB + 4 * i }
MEM [AdElt] <-- val
val <- val + 11
AdElt <- AdElt + 4
Remarques :
— On peut aussi utiliser les conditions AdElt 6= f inT AB ou AdElt < f inT AB avec
f inT AB < −debutT AB + 4 ∗ 5, en transformant la condtion de départ i 6= 5 ou i < 5.
— dans le corps du tant que, d’après l’invariant, on pourrait recalculer i à partir de AdElt
(i = (AdElt − debutT AB)/4).
Après avoir compris chacune de ces transformations, traduire la dernière version de l’algorithme
en langage d’assemblage.
5.4 Calcul de la suite de “Syracuse”

La suite de Syracuse est définie par :
U0 = un entier naturel > 0
Un = Un−1 /2 si Un−1 est pair
= Un−1 × 3 + 1 sinon
Cette suite converge vers 1 avec un cycle.
Calculer les valeurs de la suite pour U0 = 15.
Pour calculer les différentes valeurs de cette suite, on peut écrire l’algorithme suivant (à traduire
en langage d’assemblage) :
lexique :
x : un entier naturel
algorithme :
tant que x <> 1
si x est pair
alors x <-- x div 2
sinon x <-- 3 * x + 1
Equipe
Chapitre 6
TD séance 7 : Fonctions : paramètres

et résultat
6.1 Branchements aller et retour à une routine (sans question)

L’instruction permettant l’appel de fonction ou de procédure est nommée bl. Son effet est de
sauvegarder l’adresse de l’instruction qui suit l’instruction bl ... (on parle de l’adresse de retour)
dans le registre r14 aussi nommé lr (Link Register) avant de réaliser le branchement à la fonction ou
procédure. Dans la fonction appelée, Le retour à l’appelante se fait alors par l’instruction mov pc, lr.
Le schéma standard d’un programme P appelant une fonction ou procédure Q peut s’écrire :
P: ... Q: ... Pbis : mov lr,pc @ équivalent de bl

bl Q ... b Q @ en 2 instructions
... ... ... @ lr repère ici (pc+2 instr)
mov pc, lr
6.2 Un seul niveau d’appel : paramètres et variables locales en re-

gistres
6.2.1 Présentation et structure du code
La fonction coderfonc et la procédure coderproc effectuent une translation circulaire 1 à droite

dans l’alphabet : ’a’ →
3 coder(’a’,3)=’d’, ’g’ →
− 4 coder(’a’,4)=’k’ et ’z’ →
− 2 coder(’z’,2)=’b’.
−
Le premier paramètre c est un code ASCII de lettre minuscule 2 , ainsi que le résultat. Le deuxième
paramètre n est un entier naturel : 0 ≤ n ≤ 26.
Les deux routines ont la même structure de code ci-dessous, seule la manière de transmettre le
résultat à l’appelante change. La traduction de la procédure coderproc peut être traitée dans ce TD
ou reportée au TD 9 après le cours présentant les paramètres de type adresse.
1. A la base d’une méthode de cryptage simple (code de César)

2. c ∈ [’a’ . . . ’z’], soit 0x61 ≤ c ≤ 0x7a
Equipe
codefonc: @ prologue (sauvegarder) codeproc: @ prologue (sauvegarder)
code: ... @ code: ... @
... @ code de corps commun ... @ code de corps commun
edoc: @ edoc: @
@ traiter résultat (fonc) @ traiter résultat (proc)
@ épilogue (restaurer) @ épilogue (restaurer)
@ branchement retour @ branchement retour
Le corps des routines est habituellement encadré par une séquence (laissée vide dans cette première
partie de td) de sauvegarde en mémoire (prologue) et de restauration (épilogue) des registres modifiés
dans le corps de la routine. Le branchement de retour à l’appelante termine l’épilogue.
6.2.2 Traduction du code commun aux 2 routines

Traduire le code suivant : cdec = c + n; if (cdec > ’z’) {cdec = cdec - 26;}
Convention de stockage : code: ... @ cdec = ascii_c + n

— registre r0 : paramètre c ... @ if (cdec > ’z’) {
— registre r1 : paramètre n ... @ cdec = cdec - 26
— registre r12 : variable locale cdec edoc: @ }
A noter : copier le contenu de cdec dans une variable res stockée en mémoire (section data ou bss 3 )
nécessite 2 instructions ARM :
1 ldr r3,ptr_res @ r3 = adresse de res (&res en C)
2 strb r12,[r3] @ Mem[r3] = cdec (*r3 = cdec en C)
3 ...
4 ptr_res: .word res
L’instruction strb d’écriture en mémoire à l’adresse de res appartiendra soit au code de l’appelante
de la fonction, soit au code de la procédure.
6.2.3 Transmission du résultat : fonction versus procédure

Il existe deux méthodes pour stocker le résultat coder(’d’,5) à une variable résultat en mémoire :
1. la fonction coderfonc stocke la valeur de retour à un endroit convenu par la convention d’appel
associée à coderfonc et la fonction appelante exécute sa recopie dans résultat.
2. l’écriture dans résultat est effectuée directement par la procédure coderproc à laquelle l’appelle
passe en troisième paramètre l’adresse de résultat.
char lu,res1,res2; char lu,res1,res2;
// L’appelante écrit // L’appelante passe l’adresse

void main () { void main () {
res1 = coderfonc(’b’,4); coderproc(’b’,4,&res1);
LireChar(&lu); LireChar(&lu);
res2 = coderfonc(lu,2); coderfonc(lu,2,éres2));
EcrireChar(res2); EcrireChar(res2);
} }
3. Bss : section analogue à data, mais dans laquelle tous les octets seront nuls (pas de valeur initiale). Sert principa-
lement à réduire la taille des fichiers exécutables.
Equipe
Dans le code ci-dessous :
— Considérer le type char comme un entier relatif sur 8 bits
— Pres est de type char * : pres contient une adresse de variable de type char où stocker le
résultat
// L’appelée n’écrit pas // L’appelée écrit
// Convention d’appel : // Convention d’appel :
// c : r0, n : r1, // c : r0, n : r1
// valeur de retour : r2 // pres : r2
char coderfonc (char c, unsigned n) { char coderfonc (char c, unsigned n, char *pres) {
char cdec; // stockée dans r12 char cdec; // stockée dans r12
cdec = ascii_c + n; cdec = ascii_c + n;
if (cdec > ’z’) { if (cdec > ’z’) {
cdec = cdec - 26; cdec = cdec - 26;
} }
return cdec; *pres= cdec; // Mem[pres] = cdec
// valeur retournée dans r2 // Résultat dans Mem[r2]
} }
Voici un squelette de code d’appel dans l’appelante pour les deux versions de routine. Il est
instancié 2 fois (pour x=1 avec c ← ’b’ et n ← 4, et pour x=2 avec c ← lu et n ← 2) :
parfoncx: ... @ c_de_coderfonc = ... parprocx: ... @ c_de_coderproc = ...

... @ n_de_coderfonc = ... @ n_de_coderproc = ...
@ pas de 3ème paramètre @ pres_de_coderproc = adr(resx)
brfoncx: ... @ saut a coderfonc brprocx: ... @ saut a coderproc
resfoncx: ... @ resx = valeur_retour resprocx: @
Quelle(s) instruction(s) faut-il mettre dans le bloc branchement retour des routines. Pourquoi
ne peut-on pas utiliser un branchement ordinaire à une étiquette (b resfonc) ?
Traduire côte à côte (et comparer) en code ARM pour les deux versions de routine :
1. le passage des paramètres explicites dans le code de main (blocs parfonc et parproc)
2. le branchement à coderfonc ou coderproc
3. pour la fonction : le code traiter résultat de coderfonc et le bloc resf
4. pour la procédure : le code traiter résultat de coderproc (le bloc resproc est vide)
6.3 Exemple à deux niveaux d’appel : factorielle itérative
6.3.1 Utilisation d’une fonction pour le produit de deux entiers
Une instruction machine et le circuit matériel de multiplication sont devenus courants sur les
processeurs RISC modernes, mais leur présence constituait l’exception plutôt que la norme sur les
processeurs RISC de première génération. Le code de calcul de n ! ci-dessous illustre l’appel d’une
fonction mult de calcul du produit. Les variables n, res et i sont de type entier naturel.
Equipe
// Code de calcul de n! // Prototype de la fonction mult
res=1; // et convention d’appel
i = n; // x : registre r0 y : registre r1
while (i != 1) { // Valeur de retour :
res = mult(res,i); // res = res * i // registre r0 (remplace x)
i = i-1; // Tous entiers naturels 32 bits
} uint32_t mult (uint32_t x, uint32_t y);
Vous trouverez une réalisation de mult en annexe mais vous n’avez pas besoin d’en comprendre le
fonctionnement pour faire l’exercice.
calcul: ... @ res=1; Traduire le code de calcul de n ! ci-

... @ i = n; contre, avec 2 contraintes :
... @ while (i != 1) {
@ res = mult(res,i);
1. Placer le test de la condition après
corpsw: ... @ x_de_mult=res
le corps de while.
... @ y_de_mult=i
... @ saut à mult 2. Respecter la convention de sto-
suitem: ... @ res = valeur_retour_mult ckage suivante :
... @ i = i-1; (a) res dans le registre r5
condw: ... @ } (b) i dans le registre r6
... @
luclac: @ (c) n dans le registre r7
6.3.2 Variables en mémoire : un niveau d’appel
Le code est complété pour calculer factx = x !, x et factx étant des variables stockées en mémoire.
Traduire les affectations n=x et factx=res.
// entiers naturels 32 bits .bss

.balign 4
uint32_t x; x: .skip 4
uint32_t factx; factx: .skip 4
void main () { main: @sauvegardes omises

// Lire32(&x); @ Lire32(&x) omis
... @ r12 = &x
n=x; // { ... @ n = *r12 (n=Mem[r12])
calcul: ... @ res = 1
... // Calcul ...
luclac:
... @ r12 = &factx
factx=res; // } ... @ *r12 = res (Mem[r12] = res)
@restaurations omises
b exit @ à améliorer
// EcrNdecimal32(factx);
} px: .word x
pfactx: .word fcatx
Equipe
6.3.3 Deux niveaux d’appel avec fonction fact
Le bloc calcul est transformé en une fonction fact avec convention d’appel :
1. Paramètre n dans registre r7
2. Valeur de retour dans registre r5
Traduire l’affecation factx=fact(x).
uint32_t mult (uint32_t x, uint32_t y){ mult:

... ... @ >1 instructions
return ;..;
} mov pc,mr
uint32_t fact(uint32_t n) { fact: @ sauvegarde omise

... // Calcul calcul: ... @ res = 1
...
luclac:
return res; @ restauration omise

} mov pc,lr
void main () { main: @sauvegarde omise
// Lire32(&x); @ Lire32(&x)
factx=fact(x); ... @ r12 = &x

... @ n_de_fact = *r12
brfact: ... @ saut à fact
suitef: ... @ r12 = & factx
@ *r12 = val_retour_fact
// EcrNdecimal32(factx); @ EcrNDecimal32(factx)
} mov pc,lr
Donner le contenu (quelle étiquette) du registre lr à différents instants d’exécution :

1. au début de la fonction fact, lors de l’affectation res=1
2. lors de l’exécution de la première instruction de la fonction mult
3. lors de l’exécution de l’instruction de retour mov pc,lr à la fin de fact : quelle sera la prochaine
instruction exécutée ?
Indiquer à quels endroits le registre lr doit être sauvegardé puis restauré pour que l’exécution du
programme n’entre pas dans une boucle infinie.
6.4 Appel de routines d’entrées/sorties

On précise les spécifications suivantes :
— la procédure LireCar lit un caractère dans le mot mémoire dont l’adresse est donnée en pa-
ramètre, dans le registre r1.
— la procédure Ecrcar prend en paramètre d’entrée le caractère à écrire, dans le registre r1.
Equipe
// Type des procédures d’entrées/sorties :
void LireCar (char *destination); // Mem[destination] = caractère lu au clavier
void EcrCar (char a_ecrire); // Affiche a_ecrire à l’écran
@ variante possible en section data

.bss .data
lu: .skip 1 lu: .byte 0
res1: .skip1 res1: .byte 0
res2: .skip 1 res2: .byte 0
.text
main:
@ LireCar(&lu)
... @ A COMPLETER
bl Lirecar
@ le caractère lu est dans la zone data à l’adresse lu
.
@ EcrCar(res2) : le caractère à écrire doit ^
etre dans r1
... @ A COMPLETER
bl EcrCar
......
ptr_lu: .word lu
ptr_res2: .word res2
Compléter la traduction des appels à LireCar et Ecrcar dans la première partie du TD.
Traduire les appels aux routines de lecture et écriture dans le code fonction de main qui appelle
fact.
Equipe
Chapitre 7
TD séance 8 : Appels/retours de
procédures, action sur la pile
7.1 Mécanisme de pile
La pile est une zone de la mémoire. Elle est accessible par un registre particulier appelé pointeur
de pile (noté sp, pour stack pointer) : le registre sp contient une adresse qui repère un mot de la
zone mémoire en question.
On veut effectuer les actions suivantes :
— empiler : on range une information (en général le contenu d’un registre) au sommet de la pile.
— dépiler : on ”prend” le mot en sommet de pile pour le ranger par exemple dans un registre.
Le tableau ci-dessous décrit les différentes façons de mettre en oeuvre une pile en fonction des
conventions possibles pour le sens de progression (vers les adresses croissantes ou décroissantes) et
pour la contenu de la case mémoire pointée (vide ou pleine).
sens croissant croissant décroissant décroissant

pointage 1er vide dernier plein 1er vide dernier plein
empiler reg M[sp]←reg sp←sp+1 M[sp]←reg sp ←sp-1
sp←sp+1 M[sp]←reg sp←sp-1 M[sp]←reg
dépiler reg sp←sp-1 reg←M[sp] sp←sp+1 reg←M[sp]
reg←M[sp] sp←sp-1 reg←M[sp] sp←sp+1
Dans le TD et dans tout le semestre, on travaille avec un type de mise en oeuvre. On choisit celle qui
est utilisée dans le compilateur arm-eabi-gcc c’est-à-dire ”décroissant, dernier plein” (Cf. figure 7.1).
Equipe
Mem Mem
0 0
sommet de pile
après
avant
SP
SP
max max
empiler
Figure 7.1 – Mise en oeuvre de la pile. La pile progresse vers les adresses décroissantes, le pointeur de
pile repère la dernière information empilée
Exercices : utilisation de la pile

Supposons que la pile soit comprise entre les adresses 3000 comprise et 30F0 exclue. Le pointeur
de pile est initialisé avec l’adresse 30F0. Dans cet exercice on empile des informations de taille 1 octet.
Questions :
— Quelle est la valeur de sp quand la pile est pleine ?
— De combien de mots de 32 bits dispose-t-on dans la pile ?
— De combien d’octets dispose-t-on dans la pile ?
— Ecrire en ARM les deux instructions permettant d’empiler le contenu d’un octet du registre
r0. Dans la suite du TD on ecrira : empiler r0.
— Ecrire en ARM les deux instructions permettant de depiler le sommet de pile dans le registre
r0. Dans la suite du TD on ecrira : depiler r0.
— Dessiner l’état de la mémoire après chacune des étapes du programme suivant : mov r0,#
7; empiler r0; mov r0, # 2; empiler r0; mov r0, # 5; empiler r0; mov r0, # 47;
depiler r0; depiler r0; mov r0, # 9; empiler r0
— Reprendre l’exercice si on travaille avec des informations codées sur 4 octets. Comment modifier
le code de empiler et depiler ?
7.2 Appel et retours de procédures

On travaille avec le programme ci-dessous ; les procédures ”A”, ”B” et ”C” sont rangés aux adresses
10, 60 et 80.
Equipe
Remarque : il s’agit du programme donné en cours dans lequel on a remplacé les Ai, Bi et Ci par
des vraies instructions.
10 A1= mov r0, # 0 60 B1= empiler r0 80 C1= mov r0, # 47
14 A2= empiler r0 68 B2= add r0, r0, # 1 84 bl 60 (B)
1c bl 60 (B) 6c B3= depiler r0 88 C2= empiler r0
20 A3= mov r5, #28 74 mov pc, lr 90 bl si condX 80 (C)
24 bl 80 (C) 94 C3= mov r2, r5
28 A4= depiler r0 98 C4= depiler r0
a0 mov pc, lr
Questions : Le programme C est incorrect. Expliquer pourquoi et le corriger en conséquence.

Donner une trace de l’exécution du nouveau programme en indiquant après chaque instruction le
contenu des registres et de la pile.
pc inst sp r0 m[30f0] m[30ec] m[30e8] m[30e4] m[30e0]
? ? 30f0 ? ? ? ? ? ?
10 mov r0, # 0 30f0 0 ? ? ? ? ?
14 empiler r0 30ec 0 ? 0 ? ? ?
Equipe
Chapitre 8
TD séance 9 : Correction partiel
Correction du contrôle donné pendant la semaine de partiel.
Equipe
Chapitre 9
TD séance 10 : Paramètres dans la

pile, paramètres passés par l’adresse
9.1 Gestion des paramètres et des variables dans la pile

Reprendre les fonctions codefonc, fact0 et mul du TD7.
Exercices :
— transformer la traduction de ces fonctions en langage ARM pour gérer le passage des paramètres
et les variables locales dans la pile. Écrire les appels qui correspondent.
— reprendre les exemples traités précédemment dans ce TD et effectuer les sauvegardes nécessaires
de temporaires dans la pile.
9.2 Paramètre passé par adresse

9.2.1 Un premier exemple
Traduire (si cela n’a pas été fait au TD7) la fonction coderproc et son appel en passant les
paramètres par les registres.
Reprendre cette traduction en supposant que les 3 paramètres explicites sont à présent passés
dans la pile (paramètre de gauche c en sommet de pile). On pourra si nécessaire passer par une
première version dans laquelle les paramètres sont dans data ou bss.
9.2.2 Une version récursive de procédure calculant factorielle

On considère la version suivante du calcul de la factorielle d’un entier :
procedure fact2 (donnée n: entier, adresse fn: entier) {

int fnmoins1;
si (n == 1)
alors mem[fn] = 1;
sinon
fact2 (n-1, adresse de fnmoins1);
mem[fn] = n * fnmoins1;
}
n, fn : entier
Equipe
Lire (n)
fact2 (n, adresse de fn)
Ecrire (fn)
Exercice : donner une traduction en langage d’assemblage ARM de cette procédure.
Equipe
Chapitre 10
TD séance 11 : Etude du code produit

par le compilateur arm-eabi-gcc,
optimisations
10.1 Un premier exemple

Soit un programme écrit en langage C dans le fichier premier.c.
1 #include "stdio.h"
2 #include "string.h"
3
4 #define N 10
5
6 int main () {
7 char chaine [N] ;
8 int i ;
9
10 printf ("Donner une chaine de longueur inferieure a %d:\n", N);
11 fgets (chaine, N, stdin);
12 printf ("la chaine lue est : %s\n",chaine);
13 i = strlen (chaine) ;
14 printf ("la longueur de la chaine lue est : %d\n", i);
15 }
Nous le compilons sans optimisations (option -O0) et produisons le code en langage d’assemblage
ARM (option -S) avec la commande suivante : arm-aebi-gcc -O0 -S premier.c. Le code en langage
d’assemblage est produit dans le fichier premier.s (Cf. Annexe 10.5).
Questions :
1. Le premier appel à la fonction printf a 2 paramètres : une chaı̂ne de caractères et un entier.
Ces paramètres sont passés dans des registres, lesquels ?
2. Observez maintenant l’appel à la fonction fgets. Retrouvez ses paramètres dans le code.
3. La fonction strlen a un paramètre et un résultat. Où sont rangées ces informations dans le
code ?
4. Déduire du code la convention utilisée par le compilateur pour le passage des paramètres et le
retour des résultats de fonctions.
5. Quel est l’effet des 3 premières instructions du code assembleur de main ?
6. Quel est l’effet des 3 dernières instructions du code assembleur de main ?
Equipe
10.2 Programme avec une procédure qui a beaucoup de paramètres
Considérons le programme bcp param.c écrit en langage C suivant :
1 include "stdio.h"
2
3 static long int Somme (long int a1, long int a2, long int a3, long int a4, long int a5,
4 long int a6, long int a7, long int a8, long int a9, long int a10) {
5 long int x1,x2,x3,x4,x5,x6,x7,x8,x9,x10;
6 long int y;
7
8 x1=a1+1; x2=a2+1; x3=a3+1; x4=a4+1; x5=a5+1;
9 x6=a6+1; x7=a7+1; x8=a8+1; x9=a9+1; x10=a10+1;
10 y = x1+x2+x3+x4+x5+x6+x7+x8+x9+x10;
11 return (y);
12 }
13
14 int main () {
15 long int z;
16
17 z = Somme (1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
18 printf("La somme des entiers de 1 a 10 plus 10 vaut %d\n", z);
19 }
Le code produit dans le fichier bcp param.s par la commande : arm-aebi-gcc -O0 -S
bcp param.c est dans le paragraphe 10.6.
Questions :
1. Observez le code du main. Etudier le contenu de la pile avant l’appel bl Somme. Comment sont
passés les paramètres à la fonction Somme ?
2. Où est rangé le résultat rendu par la fonction Somme ?
3. Où est rangée la variable locale z ?
4. Observez le code de la fonction Somme. Dessiner la pile et retrouvez comment sont récupérés les
paramètres. Où sont rangées les variables locales : x1,x2,x3,x4,x5,x6,x7,x8,x9,x10 et y ?
10.3 Les variables locales peuvent prendre beaucoup de place

Considérons le programme var pile.c écrit en langage C suivant :
2
3 #define N 100
4
5 short int Compare2Chaines (char *s1, char *s2) {
6 char *p1, *p2 ;
7
8 p1 = s1 ; p2 = s2 ;
9 while ( *p1 && *p2 && (*p1 == *p2) ) {
10 p1++ ; p2++ ;
11 }
12 return (*p1 == 0) && (*p2 == 0) ;
13 }
14
Equipe
15 int main () {
16 short int r ;
17 char chaine1 [N], chaine2[N] ;
18
19 printf("Chaine 1, de moins de 99 caracteres : \n");
20 fgets (chaine1, N, stdin);
21 printf("Chaine 2, de moins de 99 caracteres : \n");
22 fgets (chaine2, N, stdin);
23
24 r = Compare2Chaines (chaine1,chaine2);
25
26 printf("Sont-elles egales ? %s !\n", (r ? "oui" : "non"));
27 }
Le code produit dans le fichier var pile.s par la commande : arm-aebi-gcc -O0 -S var pile.c
est dans le paragraphe 10.7.
Questions :
1. Dans le main le compilateur réserve 208 octets. Comment sont-ils utilisés ?
2. Quels sont les paramètres de la fonction Compare2Chaines ?
3. Observez le code suivant le retour de l’appel à Compare2Chaines. Commentez précisément les
lignes entre mov r3, r0 et mov r1, r3. Quels sont les paramètres passés à la fonction printf
qui suit ?
4. Commentez le code de la fonction Compare2Chaines. Comment est généré le code d’une ins-
truction while ?
10.4 Le programmeur peut aussi aider ...

Soit le programme suivant, en langage C, qui compte le nombre de bits 0 et 1 (N0 et N1 ) à 1 pour
les entiers N entre 1 et NMax à l’aide d’une double boucle.
2 #define NMax 1000000000
3
4 int main() {
5 int i,j,zero,tab[2]; i=NMax;zero=0;tab[0]=0;tab[1]=0;
6 for(i=NMax;i;i--) {
7 for(j=1;j>=0;j--) {
8 if (i&(1<<j)) {
9 tab[j]++;}
10 if (j==0) {
11 zero++;}}}
12 printf("%d - %d - %d\n",tab[0],tab[1],zero);
13 return;}
La boucle extérieure, sur i, passe en revue tous les entiers entre 1 et Nmax (en sens inverse).
La boucle intérieure, sur j, compte les 0 pour les bits en position j (j=1 puis j=0). Selon la théorie,
deux boucles imbriquées peuvent être réécrites en une seule boucle et parfois cela permet d’éviter des
branchements coûteux ...
— Réécrire le programme en conservant le traitement effectué avec une seule boucle globale.
Conserver la gestion de i et de j (en particulier les lignes à l’intérieur de la boucle interne, i.e.
les lignes 8, 9, 10 et 11, ne doivent pas être modifiées)
Equipe
— Réécrire ce programme une seconde fois en déroulant la boucle intérieure, c’est à dire en faisant
disparaı̂tre j.
— Discuter sur le gain en temps susceptible d’être obtenu avec les deux programmes précédents
(pour la réponse effective, attendre le TP)
10.5 Annexe : premier.s

1 .cpu arm7tdmi
2 .fpu softvfp
3 .eabi_attribute 20, 1
11 .file "premier.c"
12 .section .rodata
13 .align 2
14 .LC0:
15 .ascii "Donner une chaine de longueur inferieure a %d:\012\000"
16 .align 2
17 .LC1:
18 .ascii "la chaine lue est : %s\012\000"
19 .align 2
20 .LC2:
21 .ascii "la longueur de la chaine lue est : %d\012\000"
22 .text
23 .align 2
24 .global main
25 .type main, %function
26 main:
27 @ Function supports interworking.
28 @ args = 0, pretend = 0, frame = 16
29 @ frame_needed = 1, uses_anonymous_args = 0
30 stmfd sp!, {fp, lr}
31 add fp, sp, #4
32 sub sp, sp, #16
33 ldr r0, .L2
34 mov r1, #10
35 bl printf
36 ldr r3, .L2+4
37 ldr r3, [r3, #0]
38 ldr r3, [r3, #4]
39 sub r2, fp, #20
40 mov r0, r2
41 mov r1, #10
42 mov r2, r3
43 bl fgets
44 sub r3, fp, #20
45 ldr r0, .L2+8
46 mov r1, r3
47 bl printf
48 sub r3, fp, #20
Equipe
49 mov r0, r3
50 bl strlen
51 mov r3, r0
52 str r3, [fp, #-8]
53 ldr r0, .L2+12
54 ldr r1, [fp, #-8]
55 bl printf
56 mov r0, r3
57 sub sp, fp, #4
58 ldmfd sp!, {fp, lr}
59 bx lr
60 .L3:
61 .align 2
62 .L2:
63 .word .LC0
64 .word _impure_ptr
65 .word .LC1
66 .word .LC2
67 .size main, .-main
68 .ident "GCC: (GNU) 4.5.3"
10.6 Annexe : bcp param.s

1 .cpu arm7tdmi
2 .fpu softvfp
11 .file "bcp_param.c"
12 .text
13 .align 2
14 .type Somme, %function
15 Somme:
19 @ link register save eliminated.
20 str fp, [sp, #-4]!
21 add fp, sp, #0
22 sub sp, sp, #68
23 str r0, [fp, #-56]
24 str r1, [fp, #-60]
25 str r2, [fp, #-64]
26 str r3, [fp, #-68]
27 ldr r3, [fp, #-56]
28 add r3, r3, #1
29 str r3, [fp, #-8]
30 ldr r3, [fp, #-60]
31 add r3, r3, #1
32 str r3, [fp, #-12]
33 ldr r3, [fp, #-64]
Equipe
34 add r3, r3, #1
35 str r3, [fp, #-16]
36 ldr r3, [fp, #-68]
37 add r3, r3, #1
38 str r3, [fp, #-20]
39 ldr r3, [fp, #4]
40 add r3, r3, #1
41 str r3, [fp, #-24]
42 ldr r3, [fp, #8]
43 add r3, r3, #1
44 str r3, [fp, #-28]
45 ldr r3, [fp, #12]
46 add r3, r3, #1
47 str r3, [fp, #-32]
48 ldr r3, [fp, #16]
49 add r3, r3, #1
50 str r3, [fp, #-36]
51 ldr r3, [fp, #20]
52 add r3, r3, #1
53 str r3, [fp, #-40]
54 ldr r3, [fp, #24]
55 add r3, r3, #1
56 str r3, [fp, #-44]
57 ldr r2, [fp, #-8]
58 ldr r3, [fp, #-12]
59 add r2, r2, r3
60 ldr r3, [fp, #-16]
61 add r2, r2, r3
62 ldr r3, [fp, #-20]
63 add r2, r2, r3
64 ldr r3, [fp, #-24]
65 add r2, r2, r3
66 ldr r3, [fp, #-28]
67 add r2, r2, r3
68 ldr r3, [fp, #-32]
69 add r2, r2, r3
70 ldr r3, [fp, #-36]
71 add r2, r2, r3
72 ldr r3, [fp, #-40]
73 add r2, r2, r3
74 ldr r3, [fp, #-44]
75 add r3, r2, r3
76 str r3, [fp, #-48]
77 ldr r3, [fp, #-48]
78 mov r0, r3
79 add sp, fp, #0
80 ldmfd sp!, {fp}
81 bx lr
82 .size Somme, .-Somme
83 .section .rodata
84 .align 2
85 .LC0:
86 .ascii "La somme des entiers de 1 a 10 plus 10 vaut %d\012\000"
87 .text
88 .align 2
89 .global main
Equipe
91 main:
96 add fp, sp, #4
97 sub sp, sp, #32
98 mov r3, #5
99 str r3, [sp, #0]
100 mov r3, #6
101 str r3, [sp, #4]
102 mov r3, #7
103 str r3, [sp, #8]
104 mov r3, #8
105 str r3, [sp, #12]
106 mov r3, #9
107 str r3, [sp, #16]
108 mov r3, #10
109 str r3, [sp, #20]
110 mov r0, #1
111 mov r1, #2
112 mov r2, #3
113 mov r3, #4
114 bl Somme
115 str r0, [fp, #-8]
116 ldr r0, .L3
117 ldr r1, [fp, #-8]
118 bl printf
119 mov r0, r3
120 sub sp, fp, #4
122 bx lr
123 .L4:
124 .align 2
125 .L3:
126 .word .LC0
128 .ident "GCC: (GNU) 4.5.3"
10.7 Annexe : var pile.s

1 .cpu arm7tdmi
2 .fpu softvfp
11 .file "var_pile.c"
12 .text
13 .align 2
14 .global Compare2Chaines
Equipe
15 .type Compare2Chaines, %function
16 Compare2Chaines:
20 @ link register save eliminated.
21 str fp, [sp, #-4]!
22 add fp, sp, #0
23 sub sp, sp, #20
24 str r0, [fp, #-16]
25 str r1, [fp, #-20]
26 ldr r3, [fp, #-16]
27 str r3, [fp, #-8]
28 ldr r3, [fp, #-20]
29 str r3, [fp, #-12]
30 b .L2
31 .L4:
32 ldr r3, [fp, #-8]
33 add r3, r3, #1
34 str r3, [fp, #-8]
35 ldr r3, [fp, #-12]
36 add r3, r3, #1
37 str r3, [fp, #-12]
38 .L2:
39 ldr r3, [fp, #-8]
40 ldrb r3, [r3, #0] @ zero_extendqisi2
41 cmp r3, #0
42 beq .L3
43 ldr r3, [fp, #-12]
45 cmp r3, #0
46 beq .L3
47 ldr r3, [fp, #-8]
49 ldr r3, [fp, #-12]
51 cmp r2, r3
52 beq .L4
53 .L3:
54 ldr r3, [fp, #-8]
56 cmp r3, #0
57 bne .L5
58 ldr r3, [fp, #-12]
60 cmp r3, #0
61 bne .L5
62 mov r3, #1
63 b .L6
64 .L5:
65 mov r3, #0
66 .L6:
67 mov r3, r3, asl #16
68 mov r3, r3, lsr #16
69 mov r3, r3, asl #16
70 mov r3, r3, asr #16
Equipe
71 mov r0, r3
72 add sp, fp, #0
73 ldmfd sp!, {fp}
74 bx lr
75 .size Compare2Chaines, .-Compare2Chaines
76 .section .rodata
77 .align 2
78 .LC0:
79 .ascii "Chaine 1, de moins de 99 caracteres : \000"
80 .align 2
81 .LC1:
82 .ascii "Chaine 2, de moins de 99 caracteres : \000"
83 .align 2
84 .LC2:
85 .ascii "oui\000"
86 .align 2
87 .LC3:
88 .ascii "non\000"
89 .align 2
90 .LC4:
91 .ascii "Sont-elles egales ? %s !\012\000"
92 .text
93 .align 2
94 .global main
96 main:
101 add fp, sp, #4
102 sub sp, sp, #208
103 ldr r0, .L10
104 bl puts
105 ldr r3, .L10+4
106 ldr r3, [r3, #0]
107 ldr r3, [r3, #4]
108 sub r2, fp, #108
109 mov r0, r2
110 mov r1, #100
111 mov r2, r3
112 bl fgets
113 ldr r0, .L10+8
114 bl puts
115 ldr r3, .L10+4
116 ldr r3, [r3, #0]
117 ldr r3, [r3, #4]
118 sub r2, fp, #208
119 mov r0, r2
120 mov r1, #100
121 mov r2, r3
122 bl fgets
123 sub r2, fp, #108
124 sub r3, fp, #208
125 mov r0, r2
126 mov r1, r3
Equipe
127 bl Compare2Chaines
128 mov r3, r0
129 strh r3, [fp, #-6] @ movhi
130 ldrsh r3, [fp, #-6]
131 cmp r3, #0
132 beq .L8
133 ldr r3, .L10+12
134 b .L9
135 .L8:
136 ldr r3, .L10+16
137 .L9:
138 ldr r0, .L10+20
139 mov r1, r3
140 bl printf
141 mov r0, r3
142 sub sp, fp, #4
144 bx lr
145 .L11:
146 .align 2
147 .L10:
148 .word .LC0
149 .word _impure_ptr
150 .word .LC1
151 .word .LC2
152 .word .LC3
153 .word .LC4
155 .ident "GCC: (GNU) 4.5.3"
Equipe
Chapitre 11
TD séance 12 : Organisation d’un

processeur : une machine à pile
11.1 Description du processeur
Cette machine dispose de registres visibles par le programmeur :

— acc : accumulateur pour stocker des valeurs,
— pc : compteur de programme,
— sp : pointeur de pile.
pc est initialisé à 0 et repère la prochaine instruction à exécuter.
La pile suit la convention progression décroissante, dernier plein. sp est initialisé à 0xFE (la pile
commence donc à 0xFD).
Il y a aussi des registres non visibles par le programmeur, c’est-à-dire, qui ne peuvent pas être
utilisés dans un programme en langage machine :
— Rinst : registre instruction qui contient l’instruction en cours d’exécution,
— ma et mb : registres qui servent aux accès mémoire,
— mk1 et mk2 : registres servant à des calculs internes au processeur.
La mémoire est composé de mots de taille un octet. Les adresses sont aussi sur un octet.
Il existe des entrées sorties rudimentaires : la lecture du mot mémoire d’adresse 0xFE correspond
à une lecture au clavier et l’écriture dans le mot mémoire d’adresse 0xFF correspond à un affichage
sur l’écran.
Le répertoire d’instructions est donné dans la figure 11.1.
Le compteur programme indique la prochaine instruction à exécuter. Ainsi, lors de l’exécution de
l’instruction jumpifAccnul, la valeur du déplacement est calculée par rapport à l’adresse de l’ins-
truction suivante (c’est-à-dire, l’instruction qui sera exécutée ensuite si la condition de saut n’est pas
vérifiée).
Le code d’une instruction est choisi de telle façon que le décodage soit facilité par le test d’un
bit : load : 110 , input : 210 , output : 410 , push-acc : 810 pop-acc : 1610 , add : 3210 , dup : 6410 et
jumpifAccnul : 12810 .
La figure 11.2 décrit l’organisation générale du processeur et de la mémoire.
Equipe
instruction signification code opération taille codage
(valeurs en décimal)
load# vi acc <-- vi 1 2 mots
input acc <-- Mem[0xFE] 2 1 mot
output Mem[0xFF] <-- acc 4 1 mot
push-acc empiler acc 8 1 mot
pop-acc dépiler vers acc 16 1 mot
add ajouter le sommet et le sous-sommet 32 1 mot
de la pile, ils sont dépilés,
empiler la somme
l’accumulateur n’est pas modifié
dup dupliquer le sommet de pile 64 1 mot
jumpifAccnul depl saut conditionnel à pc+depl 128 2 mot
la condition est ”accumulateur nul”
Figure 11.1 – Les intructions de la machine à pile
MEM
0x00
PROCESSEUR programme
adresse mémoire
PC
MA
sp
Rinst
ACC mk1
pile
mk2 0xFD
0xFE interface
0xFF
donnée mémoire
MB
écran
clavier
Figure 11.2 – La machine à pile et sa mémoire
Equipe
11.1.1 Représentation en mémoire d’un programme
Donner la représentation en mémoire (en binaire et en hexadécimal) du programme en langage
d’assemblage suivant :
load# 3
push-acc
push-acc
add
pop-acc
11.1.2 Evolution des valeurs des registres lors d’une exécution

Décrire l’évolution des registres acc, pc, sp et de la pile lors de l’exécution du programme précédent.
Que se passe-t-il si le programmeur empile beaucoup ? Et que la pile ”marche” sur le programme
qui commence lui à l’adresse 0 ? Comment peut-on éviter ce problème ?
11.2 Interprétation des instructions sous forme d’un algorithme

Afin de comprendre comment évoluent les différents registres du processeur au cours de l’exécution
d’un programme on peut donner une interprétation du fonctionnement du processeur sous forme d’un
algorithme.
11.2.1 Algorithme
Donner l’algorithme d’interprétation des instructions.
11.2.2 Fonctionnement de l’algorithme

Donner les différentes valeurs contenues dans les registres non visibles du processeur au cours de
l’interpétation du programme donné en 11.1.1.
11.3 Interprétation des instructions sous forme d’un automate

On précise les opérations de base que le processeur peut effectuer : les micro-action. Une micro-
action dure un cycle d’horloge.
L’ensemble des micro-actions possibles dépend de l’organisation physique du processeur (cf. fi-
gure 11.3).
Pour notre exemple, les actions élémentaires sont les suivantes :
1. micro-actions internes au processeur :
— reg i ← reg j
— reg i ← reg j + 1
— reg i ← reg j - 1 note : -1≡+ff
— reg i ← reg j + reg k
— reg i ← mb
— ma ← reg i
— mb ← reg i (via l’UAL)
— ma ← 0xff
— ma ← 0xfe
— ma ← 0
— reg i ← 0
Equipe
BusAd
ma
0 0xfe 0xff
Egal 0 ? oui/non
busA
op1
UAL
acc pc sp mk1 mk2 res
busB
op2
busC
BusDon
mb
opérations UAL
res=op1
res=op1 + 1
res=op1 − 1 Rinst compare 1,2,4,... oui/non
res=op1 + op2
Figure 11.3 – Organisation de la machine à pile
Equipe
2. micro-actions permettant l’accès à la mémoire :
— lecture mémoire : mb ← Mem [ma]
— écriture mémoire : Mem [ma] ← mb
avec reg i, reg j, reg k ∈ { sp, pc, mk1, mk2, acc }.
On dispose des tests de la valeur contenue dans le registre Rinst : Rinst = code de load#, code
de add, etc.
Par ailleurs, le “calcul” acc = acc + 0 permet de tester si acc est nul où non.
11.3.1 Séquence de micro-actions pour une instruction

Ecrire la suite d’actions élémentaires (micro-actions) de la liste ci-dessus pour chacune des instruc-
tions.
11.3.2 Automate d’interprétation, graphe de contrôle

Proposer un automate d’interprétation des instructions pour la machine à pile. Il s’agit de rassem-
bler l’ensemble des séquences de micro-actions en mettant en évidence des sous-séquences communes.
11.4 Un autre exemple

Voici un programme pour cette machine :
load# -1
push
dup
load# 4
push
TITI: add
pop
dup
push
jumpifAccnul TOTO
load# 0
jumpifAccnul TITI
TOTO: load# 5a
output
11.4.1 Questions
1. Donner le code en hexadécimal ainsi que son implantation en mémoire à partir de l’adresse 0.
La question intéressante est la valeur du déplacement pour les instructions de branchements.
2. Donner l’évolution des valeurs dans les registres et dans la pile lors de l’exécution de ce pro-
gramme.
3. Donner la trace en terme d’états du graphe de contrôle du processeur lors de l’exécution de ce
programme.
11.5 Optimisation du graphe de contrôle

Nous pouvons envisager plusieurs types d’optimisations : diminuer le temps de calcul des instruc-
tions ou diminuer le nombre d’états du graphe de contrôle.
Equipe
11.5.1 Temps de calcul d’une instruction
Une micro-action dure le temps d’une période d’horloge. Choisir une fréquence et calculer le temps
de calcul de chaque instruction du processeur étudié pour le graphe de contrôle proposé dans le
paragraphe 11.3.2.
Pouvez-vous améliorer ce temps de calcul ? Quelles sont les parties incompressibles ?
11.5.2 Nombre d’états du graphe de contrôle

Est-il possible de diminuer le nombre d’états du graphe proposé :
— avec la même partie opérative ?
— en modifiant la partie opérative : ajoût de registres, de bus, etc. ?
Equipe
Troisième partie
Travaux Pratiques
Equipe
Chapitre 1
TP séance 1 : Représentation des

informations (ex. : images,
programmes, entiers)
1.1 Comment est représentée une image ?

On va utiliser le format bitmap. Ce format permet de décrire une image extrêmement simple en
noir et blanc ; on peut par exemple l’utiliser pour décrire une icône.
Une image est un ensemble de points répartis dans un rectangle. L’image est définie par un texte
de programme en langage C comprenant la taille du rectangle et la valeur de chacun des points : noir
ou blanc. Un point est décrit par 1 bit (vrai = 1 = noir).
On donne ci-dessous le contenu du fichier image.bm codant une image de dimensions 16 × 16 dans
laquelle tous les points sont blancs.
#define image_width 16
#define image_height 16
static unsigned char image_bits[] = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};
1.1.1 Modifier une image “à la main”

Le naturel 0 codé sur 8 bits s’écrit 0x00 en hexadécimal et 0000 0000 en binaire ; il représente 8
points blancs contigus alignés horizontalement.
— Au moyen d’un éditeur de texte (nedit par exemple), modifiez le fichier image.bm de façon à
ce qu’il contienne la description d’une image de dimensions 16 × 16 dans laquelle la troisième
ligne est noire. Vous afficherez votre image avec la commande : bitmap image.bm.
Pour sortir, sélectionner Quit dans le menu File.
— Quelles modifications avez-vous apportées au fichier image.bm ?
1.1.2 Codage d’une image

Effectuez la manipulation suivante :
— Créez au moyen de votre éditeur de texte un fichier monimage.bm contenant une image de
dimensions 16 × 16 au format bitmap.
Equipe
Tous les points de cette image doivent être blancs, excepté ceux de la première ligne qui doit
avoir l’aspect suivant :

— Utilisez le programme bitmap pour afficher l’image contenue dans le fichier monimage.bm.
Vérifiez que l’image affichée correspond bien au résultat attendu.
— Ecrivez en binaire les valeurs que vous avez codées dans le fichier. Expliquez le codage que vous
avez utilisé pour obtenir l’image demandée.
1.2 Comment est représenté un programme ?

Considérons un programme écrit en langage C : prog.c.
/* prog.c */
int NN = 0xffff;
char CC[8] = "charlot";
int main() {
NN = 333;
NN= NN + 5;
}
Vous allez le compiler, c’est-à-dire le traduire dans un langage interprétable par une machine avec
la commande : arm-eabi-gcc -c prog.c. Vous obtenez le fichier prog.o.
C’est du “binaire”... Nous allons le regarder avec différents outils.
1.2.1 Une première expérience

Essayez successivement les quatre expériences suivantes :
— nedit prog.o
— more prog.o
— less prog.o
— cat prog.o
Qu’avez-vous observé ? Qu’en concluez-vous ?
1.2.2 Affichage en hexadécimal

Tapez : hexdump -C prog.o. Vous observez des informations affichées en hexadécimal et les ca-
ractères correspondants sur la droite. Plus précisément, sur la gauche vous avez des adresses, c’està-dire
des numéros qui comptent les octets (paquets de 8 bits), et au centre l’information qui est affichée en
hexadécimal.
Combien d’octets sont codés sur une ligne affichée ? Combien de mots de 32 bits cela représente-
t-il ?
Les caractères de la chaine de caractères "charlot" sont codés en ASCII : chaque caractère est
représenté sur un octet (8 bits, 2 chiffres hexadécimaux). Pour avoir le code ascii d’un caractère, tapez
man ascii ou consultez votre documentation technique.
Repérez la chaı̂ne "charlot" dans l’affichage à droite et trouvez l’information correspondante au
centre. A quelles adresses est rangée cette chaı̂ne ?
La valeur ffff de l’entier NN n’est pas bien loin de "charlot", la trouver.
La chaine NN est-elle dans ce fichier ? Au même endroit que les deux valeurs précédentes ?
Grâce à la commande xterm & on peut ouvrir plusieurs fenêtres et comparer ce qu’affiche hexdump
et ce qu’affiche nedit pour un même fichier. Comparer les caractères dont le code est compris entre
0x20 et 0x7f et ceux qui ne sont pas dans cet intervalle.
Equipe
1.2.3 Affichage plus “lisible”
Le programme a été traduit dans le langage machine ARM.
La commande arm-eabi-objdump -S prog.o donne la séquence d’instructions ARM qui correspond
à nos instructions C. On peut lire l’adresse de l’instruction, puis son code en hexadécimal et enfin les
mnémoniques correspondants en langage d’assemblage.
On va repérer le code qui correspond à l’instruction NN = 333. C’est fait en deux fois :
10: e3a03f53 mov r3, #332

14: e2833001 add r3, r3, #1
La question suivante étant un peu plus complexe, vous en chercherez la réponse chez vous ou
en fin de séance si vous avez terminé en avance. Pour cela il faut lire en détail le paragraphe 2.3
de la documentation technique et la remarque du paragraphe 2.1.4. Pourquoi le processeur ARM ne
permet-il pas d’écrire mov r3, #333 ?
arm-eabi-gcc traduit un programme écrit dans le langage C en un programme écrit en langage
machine du processeur ARM.
Avec d’autres options le compilateur gcc traduit dans le langage machine d’autres processeurs. Par
exemple, par défaut, gcc effectue la traduction pour le processeur contenu dans la machine sur laquelle
vous travaillez ; dans votre cas c’est le langage machine du processeur INTEL... Effectuez l’expérience
suivante :
gcc -c prog.c
hexdump -C prog.o
objdump -S prog.o
Regardez la ligne ci-dessous :
11: c7 05 00 00 00 00 4d movl $0x14d,0x0
Quel nombre représente 0x14d ?

Combien d’instructions a-t-il fallu pour traduire l’affectation NN=333 pour chacun des deux pro-
cesseurs ?
1.3 Langage d’assemblage/langage machine

Le but de cette partie est de traduire des instructions écrites en langage d’assemblage ARM en
langage machine.
Une instruction en langage d’assemblage est traduite en une instruction en langage machine par
une suite de bits. On exprime cette suite de bits en hexadécimal car c’est plus facile à lire.
A l’aide de la documentation technique ARM, traduire les instructions ci-dessous. Pour chacune,
mettre en évidence le codage de la valeur immédiate, la valeur du bit S, la valeur du bit I, le codage
du numéro des registres.
ADD r10, r2, #10

ADD r10, r2, #17
ADDS r10, r2, #10
ADD r10, r2, r3
Pour vérifier vos résultats effectuez l’expérience suivante :

— On fabrique 2 programmes en langage d’assemblage presque identiques. Par exemple, le pro-
gramme prog1.s se différencie du programme prog1.var1.s par une instruction. Laquelle ?
Equipe
— Produire les 2 programmes en langage machine : arm-eabi-gcc -c prog1.s et arm-eabi-gcc
-c prog1.var1.s).
— Observer leur contenu : arm-eabi-objdump -S prog1.o et arm-eabi-objdump -S
prog1.var1.o.
— Comment interprétez-vous les résultats de cette expérience ?
Reproduire la même expérience pour les instructions : ADDS r10, r2, #10 (programme
prog1.var2.s) et ADD r10, r2, r3 (programme prog1.var3.s).
Ci-dessous le contenu des fichiers servant à cette expérience.
@-------------------- prog1.s ----------------------

.text
.global main
main:
ADD r10, r2, r0
ADD r10, r2, #10
fin: BAL fin
@-------------------- prog1.var1.s ----------------------

.text
.global main
main:
ADD r10, r2, r0
ADD r10, r2, #17
fin: BAL fin
@-------------------- prog1.var2.s ----------------------

.text
.global main
main:
ADD r10, r2, r0
ADDS r10, r2, #10
fin: BAL fin
@-------------------- prog1.var3.s ----------------------

.text
.global main
main:
ADD r10, r2, r3
ADD r10, r2, #10
fin: BAL fin
1.4 Codage des couleurs

Nous nous intéressons ici au codage des couleurs. On utilise le codage dit RGB. Il s’agit pour coder
une couleur de donner une proportion des trois couleurs rouge (Red), vert (Green) et bleu (Blue) pour
les images fixes ou animées.
Une couleur est codée par un nombre exprimé en hexadécimal sur 3 × 2 chiffres dans l’ordre :
Rouge, Vert, Bleu ; ff représentant la proportion maximale. Par exemple, 00ff00 code la couleur
verte, 000012 code une nuance de bleu.
Equipe
Pour plus d’informations vous pouvez regarder :
http://en.wikipedia.org/wiki/RGB color model
La figure 1.1 donne la description d’une image dans le format xpm. Cette image comporte deux
segments. L’image est décrite dans le langage C à l’aide d’un tableau de caractères. On y trouve la
taille de l’image (32 × 32), le nombre de caractères utilisés pour la représenter (3), la couleur (au
codage RGB) associée à chacun des caractères, et enfin la matrice de points, un caractère étant associé
à un point. None désigne une couleur prédéfinie dans le système.
On remarque que la proportion d’une couleur est codée sur deux chiffres hexadécimaux, ff
représentant le maximum.
1.4.1 Fabriquer une image à la main

1. Récupérez le fichier lignes.xpm et affichez l’image avec xli, xpmview ou mirage.
2. Quelles sont les couleurs des deux segments ? Donnez le code de chacune de ces deux couleurs.
3. Editez ce fichier avec un éditeur classique et modifiez la couleur d’un segment en modifiant les
proportions de la couleur de ses points puis affichez à nouveau l’image. Faites éventuellement
plusieurs essais et observez qu’une légère modification de la proportion d’une couleur de base
n’est pas visible à l’oeil. A partir de quelle proportion distingue-t-on une différence ?
4. Remplacez un des caractères codant un point d’une couleur donnée par un autre. Par exemple,
remplacer a par s. Pensez à effectuer ce remplacement dans la définition de la couleur du point
et dans la matrice de points. Quel est l’effet d’une telle modification ?
Equipe
/* XPM */
static char *lignes[]={ /* le fichier doit s’appeler lignes.xpm */
"32 32 3 1",
". c None",
"# c #f0f000",
"a c #ff0000",
"................................",
"................................",
"................................",
"................................",
"................................",
"................................",
"...############.................",
"................................",
"................................",
"................................",
"..................a.............",
"..................a.............",
"..................a.............",
"..................a.............",
"..................a.............",
"..................a.............",
"..................a.............",
"..................a.............",
"..................a.............",
"..................a.............",
"................................",
"................................",
"................................",
"................................",
"................................",
"................................",
"................................",
"................................",
"................................",
"................................",
"................................",
"................................"};
Figure 1.1 – Le fichier : lignes.xpm
Equipe
Chapitre 2
TP séance 2 : Codage et calculs en

base 2
2.1 Calculs à effectuer à la main (rappel : 0x → base 16)

2.1.1 Conversions
Convertir 27710 en bases 2 et 16, 0x4E en bases 2 et 10 et 110110012 en bases 10 et 16.
2.1.2 Addition
Poser en décimal sur 3 chiffres, en hexadécimal sur 2 chiffres et en binaire sur 8 bits l’addition
5710 + 0xa3. Sur l’opération binaire :
1. faire apparaı̂tre les retenues ci , la dernière retenue C = c8
2. les deux dernières retenues sont-elles égales ?
3. que valent les indicateurs N, Z et V ?
4. que valent les opérandes et le résultat apparent sur 8 bits et l’opération est-elle correcte ?
— s’il s’agit d’entiers naturels
— s’il s’agit d’entiers relatifs
Quelles réponses changent si cette même addition est réalisée sur 9 bits ?
2.1.3 Soustraction
Poser en décimal sur 2 chiffres, en hexadécimal sur 1 chiffre et en binaire sur 4 bits les soustractions
suivantes : 0xc - 0x8, 0x8 - 0xc, 0x7 - 0x7. Sur l’opération binaire sur 4, puis sur 5 bits en observant
les changements :
1. faire apparaı̂tre les emprunts ei et le dernier emprunt E=e5 (puis e6 )
2. que valent les indicateurs N, Z et V ?
3. interpréter l’opération en supposant qu’il s’agisse d’entier naturels, puis d’entiers relatifs
4. la soustraction est-elle possible dans l’ensemble N ?
5. la soustraction donne-t-elle un résultat correct dans l’ensemble Z ?
Equipe
2.1.4 Soustraction par addition du complément à 2
Poser en binaire sur 4 puis sur 5 bits l’addition 0xc + 0x7 en utilisant une retenue initiale non
nulle (c0 = 1). Comparer la ligne des retenues (dont C) avec celles des emprunts (dont E) de la
soustraction précédente 0xc-0x8.
recommencer avec 0x8 + 0x3 et la soustraction précédente 0x8 - 0xC.
Quelle doit être la valeur de C pour que la soustraction dans N soit possible ?
2.2 Présentation de la calculette binaire

Voici le mode d’emploi de la calculette binaire qui vous permettra de vérifier les opérations ma-
nuelles précédentes.
Syntaxe d’utilisation
La syntaxe d’utilisation de la calculette est la suivante :
opération nombre de bits opérande gauche opérande droit
Les opérations disponibles sont les suivantes :

1. add et addsc : addition
2. sub et subsc : soustraction
3. subc2 et subsc2 : soustraction par addition du complément à deux
Le nombre de bits spécifie la taille de la machine utilisée. Le suffixe sc (show carries) pour les
additions et soustractions spécifie de détailler la génération des retenues et des emprunts.
Format des opérandes et du nombre de bits

Les entiers utilisés par la calculette binaire peuvent être spécifiés sous trois formats : décimal (par
défaut), hexadécimal (avec le préfixe 0x, comme en langage C) et binaire (avec le préfixe 0b, inconnu
du langage C).
Il est de plus possible de spécifier le complément à 1 (préfixe /) ou le complément à deux (ou

opposé : préfixe -) d’un entier 1 .
A titre d’exemple, voici plusieurs manières de spécifier l’entier 1111000010012 sur 12 bits :
1. en binaire : 0b111100001001 /0b000011110110 ou −0b000011110111
2. en hexadécimal : 0xf09 /0x0f6 ou −0x0f7
3. et en décimal : 3849 /246 ou −247.
2.3 Compréhension des indicateurs N,Z,V

Réaliser les additions sur 4 bits détaillées dans le tableau ci-dessous (a et b sont les opérandes
écrits en binaire). Pour chaque d’entre elles, compléter les informations suivantes :
1. valeurs décimales de a et b en tant qu’entiers naturels et relatifs
1. Ceci s’applique aux opérandes, mais pas au nombre de bits
Equipe
2. écriture binaire du résultat apparent Σ, et valeurs décimales en tant qu’entier naturel et relatif
3. bit de poids forts N = Σn−1 , an−1 et bn−1 .
4. indicateur V, dernière C = cn et avant-dernière cn−1 retenue
5. le résultat apparent Σ est-il correct pour des entiers relatifs, pour des entiers naturels
a b Σ N= an−1 bn−1 V C=cn cn−1 Correct ?

bin rel nat bin rel nat bin rel nat Σn−1 rel nat
0100 0011
0100 0101
1001 0110
1111 1110
0100 1000
1000 1000
Compléter les phrases suivantes : après une addition

1. Le résultat est correct pour des entiers naturels si et seulement si l’indicateur =0
2. Le résultat est correct pour des entiers relatifs si et seulement si l’indicateur =0
3. L’indicateur N n’est pertinent que pour une addition d’entiers . . . . . . (nature d’entiers)
4. L’indicateur V est vrai si et seulement si . . . . . . . . . (propriété portant sur (C,cn−1 ))
5. L’indicateur V est vrai si an−1 = et bn−1 = et Σn−1 = ou an−1 = et bn−1 = et Σn−1 =
Effectuer sur 5 bits les additions de relatifs +4 + +5 et -8 +-8. Comparer aux mêmes addition sur
4 bits. Que peut-on dire de N lorsque le résultat apparent d’une addition d’entiers relatifs est incorrect ?
Expliquer pourquoi après avoir effectué le calcul a-b sur des entiers relatifs, la condition a < b
s’écrit N etV ouN etV 2
Expliquer pourquoi après avoir effectué le calcul a-b sur des entiers naturels, la condition a < b
s’écrit C
2.4 Extension de format et opérations bit à bit

Considérez l’addition sur 4 bits de 01012 et 10112 . Trouver l’écriture binaire des opérandes sur 8
bits qui donne la même opération (le bit de poids fort de l’opérande de départ a-t-il une importance ?) :
1. sur des entiers naturels
2. sur des entiers relatifs
Effectuer sur 8 bits entre les opérandes 0xcc et 0x55 les opérations suivantes : or, and, xor.
Expliquer le résultat obtenu
Effectuer sur 12 bits les opérations suivantes entre les opérandes 0x1f5 et 3, puis 0x842 et 2 :
1. lsl (Logic Shift Left)
2. lsr (Logic Shift Right)
3. asr (Arithmetic Shift Right)
Observer les multiplications ou division effectuées (entiers naturels et entiers relatifs).

2. (N,V) = (1,0) ou (0,1)
Equipe
Chapitre 3
TP séances 3 et 4 : Codage des données
3.1 Déclaration de données en langage d’assemblage

Les données sont déclarées dans une zone appelée : data. Pour déclarer une donnée on indique la
taille de sa représentation et sa valeur ; on peut aussi déclarer une zone de données non initialisées
(sans valeur initiale) ce qui correspond à une réservation de place en mémoire.
Soit le lexique suivant en notation algorithmique :
aa : le caractère ’A’
oo : l’entier 15 sur 8 bits (1 octet)
cc : la chaine "bonjour"
rr : <’B’, 3> de type <un caractère, un entier sur 1octet>
T : le tableau d’entiers sur 16 bits [0x1122, 0x3456, 0xfafd]
xx : l’entier 65 sur 8 bits (1 octet)
On le traduit en langage d’assemblage ARM. Le fichier donnees.s contient une zone data dans
laquelle sont déclarées les données correspondant aux déclarations ci-dessus.
La directive .byte (respectivement .hword, .word) permet de déclarer une valeur exprimée sur
8 bits (respectivement 16, 32 bits). Une valeur peut être écrite en décimal (65) ou en hexadécimal
(0x41).
Pour déclarer une chaı̂ne, on peut utiliser la directive .asciz et des guillemets.
Le caractère @ marque le début d’un commentaire, celui-ci se poursuivant jusqu’à la fin de la ligne.
.data
aa: .byte 65 @ .byte 0x41
oo: .byte 15 @ .byte 0x0f
cc: .asciz "bonjour"
rr: .byte 66 @ .byte 0x42
.byte 3
T: .hword 0x1122
.hword 0x3456
.hword 0xfafd
xx: .byte 65
Nous allons maintenant observer le codage en mémoire de cette zone data. Traduire le programme
donnees.s en binaire avec la commande :
arm-eabi-gcc -c -mbig-endian donnees.s.
Notez que nous utilisons l’option -mbig-endian dans le but de faciliter la lecture (rangement par
“grands bouts”). Vous pourrez en observer le fonctionnement dans la partie 3.4.2. Vous obtenez le
Equipe
fichier donnees.o. Observez le contenu de ce fichier :
arm-eabi-objdump -j .data -s donnees.o
Chaque ligne comporte une adresse puis un certain nombre d’octets et enfin leur correspondance
sous forme d’un caractère (quand cela a un sens). Dans quelle base les informations sont-elles affichées ?
Combien d’octets sont-ils représentés sur chaque ligne ? Donnez pour chacun des octets affichés la
correspondance avec les valeurs déclarées dans la zone data. Comment est codée la chaı̂ne de caractères,
en particulier comment est représentée la fin de cette chaı̂ne ?
Nous voulons maintenant représenter tous les entiers sur 32 bits ; d’où le nouveau lexique :
aa : le caractère ’A’
oo : l’entier 15 sur 32 bits
cc : la chaine "bonjour"
rr : <’B’, 3> de type <un caractère, un entier sur 32 bits>
T : le tableau d’entiers sur 32 bits [0x1122, 0x3456, 0xfafd]
xx : l’entier 65 sur 32 bits
La directive de déclaration pour définir une valeur sur 32 bits est .word.
Copiez le fichier donnees.s dans donnees2.s et modifiez donnees2.s. Compilez donnees2.s.
Quelle est maintenant la représentation de chacun des entiers de la zone data modifiée ?
3.2 Accès à la mémoire : échange mémoire/registres

3.2.1 Lecture d’un mot de 32 bits
Le problème est le suivant : la zone data contient des données dont plus particulièrement un entier
représenté sur 32 bits à l’adresse xx ; on veut copier cet entier dans un registre.
Le programme accesmem.s montre comment résoudre le problème. On commence par charger dans
le registre r5 l’adresse xx (LDR r5, ptr xx), puis on charge dans r6 le mot mémoire à cette adresse
(LDR r6, [r5]). La suite du programme permet d’afficher le contenu des registres r5 et r6.
@ accesmem.s
.data
aa: .word 24
xx: .word 266
bb: .word 42
.text
.global main
main:
LDR r5, ptr_xx
LDR r6, [r5]
@ impression du contenu de r5
MOV r1, r5
BL EcrHexa32
@ impression du contenu de r6
MOV r1, r6
BL EcrHexa32
fin: BAL exit
Equipe
ptr_xx: .word xx
Ce programme utilise une fonction d’affichage EcrHexa32 qui est définie dans un autre module es.s
(Cf. chapitre 4). Cette fonction affiche à l’écran en hexadécimal la valeur contenue dans le registre r1
obligatoirement.
Produisez l’exécutable accesmem :
arm-eabi-gcc -c es.s
arm-eabi-gcc -c accesmem.s
arm-eabi-gcc -o accesmem accesmem.o es.o
Exécutez ce programme : arm-eabi-run accesmem. Notez les valeurs affichées. Que représente
chacune d’elle ?
3.2.2 Lecture de mots de tailles différentes

Voilà un programme (accesmem2.s) utilisant les instructions : LDR, LDRH et LDRB.
Le programme es.s vous fournit également les fonctions d’affichage en décimal de la valeur conte-
nue dans le registre r1 sur 32 bits, 16 bits ou 8 bits : EcrNdecimal32, EcrNdecimal16 et EcrNdecimal8
(Cf. chapitre 4).
Ajoutez des instructions permettant l’affichage des adresses et des valeurs lues dans la mémoire de
la même façon que dans le programme précédent. Compilez de la même façon que précédemment et
exécutez.
Relevez les valeurs affichées et en particulier donnez les adresses mémoire où sont rangées les
valeurs 266, 42 et 12. Expliquez les différences entre elles.
@ accesmem2.s
.data
D1: .word 266
D2: .hword 42
D3: .byte 12
.text
.global main
main:
LDR r3, ptr_D1
LDR r4, [r3]
LDR r5, ptr_D2

LDRH r6, [r5]
LDR r7, ptr_D3

LDRB r8, [r7]
fin: BAL exit
ptr_D1: .word D1
ptr_D2: .word D2
ptr_D3: .word D3
Equipe
3.2.3 Ecriture en mémoire
L’instruction STR (respectivement STRH, STRB) permet de stocker un mot représenté sur 32 (res-
pectivement 16, 8) bits dans la mémoire.
Le programme ecrmem.s affiche la valeur rangée à l’adresse DW, puis range à cette adresse la
valeur 1048576 ; le mot d’adresse DW est alors lu et affiché. Exécutez ce programme et constatez
qu’effectivement le mot d’adresse DW a été modifié. Modifiez le programme ecrmem.s pour faire le
même genre de travail mais avec un mot de 16 bits rangé à l’adresse DH et un mot de 8 bits rangé à
l’adresse DB.
Remarque : les adresses sont toujours représentées sur 32 bits.
.data
DW: .word 0
DH: .hword 0
DB: .byte 0
.text
.global main
main:
LDR r0, ptr_DW
LDR r1, [r0]
BL EcrNdecimal32
MOV r4, #1048576 @ 1048576 = 2^20

LDR r5, ptr_DW
STR r4, [r5]
LDR r0, ptr_DW

LDR r1, [r0]
BL EcrNdecimal32
fin: BAL exit
ptr_DW: .word DW
ptr_DH: .word DH
ptr_DB: .word DB
3.3 Un premier programme en langage d’assemblage

Considérons le programme caracteres.s.
.data
cc: @ ne pas modifier cette partie
.byte 0x42
.byte 0x4f
.byte 0x4e
.byte 0x4a
.byte 0x4f
.byte 0x55
.byte 0x52
.byte 0x00 @ code de fin de chaine
Equipe
@ la suite pourra etre modifiee
.word 12
.word 0x11223344
.asciz "au revoir..."
.text
.global main
main:
@ impression de la chaine de caracteres d’adresse cc

LDR r1, ptr_cc
BL EcrChaine
@ modification de la chaine
@ A COMPLETER
@ impression de la chaine modifiee

LDR r1, ptr_cc
BL EcrChaine
fin: BAL exit
ptr_cc: .word cc
Compilez ce programme et exécutez-le ; vous constatez qu’il affiche deux fois la chaı̂ne de caractères
d’adresse cc.
Modifiez ce programme pour qu’il affiche la chaı̂ne "BONJOUR" sur une ligne puis la chaine "au
revoir..." sur la ligne suivante. Il y a plusieurs façons de traiter cette question, vous pouvez essayer
plusieurs solutions (c’est même conseillé) mais celle qui nous intéresse le plus ici consiste à utiliser
l’indirection avec un pointeur relais. Plus précisément vous devez identifier l’adresse de début de chaque
chaine (avec une étiquette) et utiliser cette étiquette pour réaliser l’affichage souhaité.
La chaı̂ne d’adresse cc est formée de caractères majuscules. Modifiez le programme en ajoutant
une suite d’instructions qui transforme chaque caractère majuscule en minuscule. On peut résoudre
ce problème sans écrire une boucle. Compilez et exécutez votre programme.
Indication : inspirez-vous de l’exercice fait en TD1. L’opération OU peut être réalisée avec l’ins-
truction ORR.
3.4 Alignements et ”petits bouts”

3.4.1 Questions d’alignements
Voici une nouvelle zone de données à définir en langage d’assemblage :
x: l’entier 9 sur 8 bits

l’entier 8 sur 8 bits
l’entier 3 sur 8 bits
z: l’entier 1024 sur 32 bits
En vous inspirant du programme accesmem.s, écrivez le programme alignements1.s comportant

la zone de données décrite ci-dessus, et une zone text consistant à lire le mot d’adresse z et à afficher
sa valeur. Que constatez-vous ?
Equipe
Le problème vient du fait que les mots de 32 bits doivent être placés à des adresses multiples de
4. De même les entiers représentés sur 2 octets doivent être stockés à des adresses multiples de 2.
Pour rétablir l’alignement insérer la ligne suivante :
.balign 4
juste avant la déclaration de l’entier z, et appelez ce nouveau programme alignements2.s.
Vérifiez que le problème est résolu.
Ecrivez un programme dans lequel vous déclarez une valeur représentée sur 16 bits et dont l’adresse
n’est pas un multiple de 2 (il suffit de placer un octet devant). Reproduisez une expérience similaire à
la précédente (pour rétablir un alignement sur une adresse multiple de 2 utilisez la directive .balign
2).
3.4.2 Questions de ”petits bouts”

Reprendre l’exercice de lecture de mots de 32 bits dans la mémoire (paragraphe 3.2.1).
Observer le contenu de la zone data du fichier accesmem avec la commande : arm-eabi-objdump
-j .data -s accesmem et retrouver les valeurs et les adresses des 3 mots déclarés dans la zone data.
Noter que la convention utilisée est le rangement par “petits bouts” (Cf. paragraphe 2.3). Pour
obtenir un rangement par “grands bouts” recompiler les fichiers source avec l’option -mbig-endian.
Faire le même exercice avec l’exercice du paragraphe 3.2.2.
Equipe
Chapitre 4
TP séance 5 : Codage de structures de

contrôle et le metteur au point gdb
4.1 Accès à un tableau

On considère l’algorithme suivant :
lexique:
TAB : un tableau de 5 entiers représentés sur 32 bits
algorithme:
TAB[0] <-- 11
TAB[1] <-- 22
TAB[2] <-- 33
TAB[3] <-- 44
TAB[4] <-- 55
1. Récupérez le fichier tableau.s. On y a traduit en langage d’assemblage les deux premières

affectations.
2. Complétez le programme de façon à réaliser l’algorithme donné en entier.
3. Compilez avec la commande : arm-eabi-gcc -Wa,--gdwarf2 tableau.s -o tableau 1
4. Observez son exécution pas à pas sous gdb ou ddd (lire ce qui suit et vous référer au para-
graphe 2.4.2).
gdb est un metteur au point (ou “débogueur”) ; il permet de suivre l’exécution d’un programme
en pas à pas c’est-à-dire une ligne de programme après l’autre ou à modifier un programme en cours
d’exécution.
Nous verrons par la suite qu’un metteur au point sert aussi à chercher des erreurs dans un pro-
gramme en stoppant celui-ci justement à l’endroit où l’on soupçonne l’erreur...
Pour utiliser gdb le programme doit avoir été compilé avec l’option -g, ce que vous avez fait (option
-gdwarf2).
Exécutez le programme sous gdb en tapant les commandes suivantes :
1. arm-eabi-gdb tableau
On lance le débogueur, nous sommes désormais dans l’environnement gdb.
1. attention, ne pas mettre d’espace avant le --gdwarf2
Equipe
2. target sim
On active le simulateur, ce qui permet d’exécuter des instructions en langage d’assemblage
ARM.
3. load
On charge le programme à exécuter dont on a donné le nom à l’appel de gdb.
4. break main
On met un point d’arrêt juste avant l’étiquette main.
5. run
Le programme s’exécute jusqu’au premier point d’arrêt exclu : ici, l’exécution du programme
est donc arrêtée juste avant la première instruction.
6. list
On voit 10 lignes du fichier source.
7. list
On voit les 10 suivantes.
8. list 10,13
On voit les lignes 10 à 13.
9. info reg
Permet d’afficher en hexadécimal et en décimal les valeurs stockées dans tous les registres.
Notez la valeur de r15 aussi appelé pc, le compteur de programme. Elle représente l’adresse de
la prochaine instruction qui sera exécutée.
10. s
Une instruction est exécutée. gdb affiche une ligne du fichier source qui est la prochaine ins-
truction (et qui n’est donc pas encore exécutée).
11. etc.
Pour l’observation de l’exécution du programme tableau, notez, en particulier, les valeurs suc-
cessives (à chaque itération) de r0, le contenu de la mémoire à partir de l’adresse debutTAB en
début de programme et après l’exécution de toutes les instructions. Sous gdb, pour afficher 5 mots en
hexadécimal, à partir de l’adresse debutTAB, utilisez la commande : x/5w &debutTAB.
4.2 Codage d’une itération

On considère l’algorithme suivant :
val <-- 11
i <-- 0
tant que i <> 5
TAB[i] <- val
i <-- i + 1
val <- val + 11
Après transformations, on l’a codé en langage d’assemblage par :
.data
debutTAB: .skip 5*4
.text
Equipe
.global main
main:
mov r3, #11 @ val <- 11

mov r2, #0 @ i <- 0
tq: cmp r2, #5 @ i-5 ??
beq fintq
@ i-5 <> 0
ldr r0, ptr_debutTAB @ r0 <- debutTAB
add r0, r0, r2, LSL #2 @ r0 <- r0 + r2*4 = debutTAB + i*4
str r3, [r0] @ MEM[debutTAB+i*4] <- val
add r2, r2, #1 @ i <- i + 1
add r3, r3, #11 @ val <- val + 11
bal tq
fintq: @ i-5 = 0
fin: bal exit
ptr_debutTAB : .word debutTAB

1. Récupérez le fichier iteration.s Compilez ce programme et exécutez-le sous gdb ou ddd.
2. Quelle est la valeur contenue dans r0 à chaque itération ?
3. Quelle est la valeur contenue dans r2 à chaque itération ?
4. Quelle est la valeur contenue dans r2 à la fin de l’itération, c’est-à-dire lorsque le contrôle est
à l’étiquette fintq ?
5. Supposons que l’agorithme soit écrit avec tant que i <= 4 au lieu de tant que i <> 5 ; le
tableau contient-t-il les même valeurs à la fin de l’itération ? Comment doit-on alors traduire
ce nouveau programme ?
6. Supposons que le tableau soit maintenant un tableau de mots de 16 bits. Comment devez-vous
modifier le programme ? Faire la modification et rendre le nouveau programme et les valeurs
dans les registres.
7. Même question pour un tableau d’octets.
4.3 Calcul de la suite de “Syracuse”

La suite de Syracuse est définie par :
U0 = un entier naturel > 0
Un = Un−1 /2 si Un−1 est pair
= Un−1 × 3 + 1 sinon
Cette suite converge vers 1 avec un cycle.
Calculer les valeurs de la suite pour U0 = 15.
Pour calculer les différentes valeurs de cette suite, on peut écrire l’algorithme suivant :
lexique :
x : un entier naturel
algorithme :
tant que x <> 1
si x est pair
alors x <-- x div 2
sinon x <-- 3 * x + 1
Equipe
Vous allez traduire cet algorithme en langage d’assemblage et vérifier que son exécution calcule
bien les éléments de la suite de Syracuse.
Quelques indications :
— L’algorithme comporte une itération dans laquelle est incluse une instruction conditionelle.
Vous pouvez traduire chacune des deux constructions en utilisant un des schémas de traduction
précédents. N’hésitez pas à utiliser autant d’étiquettes que vous voulez si cela vous rend le travail
plus lisible.
— Pour tester si un entier est pair il suffit de regarder si son bit de poids faible (le plus à droite)
est égal à 0. Pour cela vous pouvez utiliser une instruction “et logique” avec la valeur 1 ou
l’instruction TST qui exécute la même chose.
— Pour diviser un entier par 2 il suffit de le décaler à droite de 1 position.
— Pour calculer 3 ∗ x on peut calculer 2 ∗ x + x et pour multiplier un entier par 2, il suffit de le
décaler à gauche de 1 position.
Equipe
Chapitre 5
TP séances 6 et 7 : Parcours de
tableaux
5.1 Tables de multiplications

On vous propose de réaliser un programme qui remplit un tableau avec les tables de multiplication
de 1 à 10 et qui l’affiche à l’écran comme sur la figure 5.1.
Le remplissage du tableau peut être réalisé de façon itérative, suivant l’algorithme :
//Remplissage d’un tableau des multiplications de 1 à 10

//table[n-1,m-1] = n*m pour n et m compris entre 1 et 10.
LEXIQUE :
N_MAX : l’entier 10
Ligne : le type tableau sur [0..N_MAX-1] d’entiers
table : le tableau sur [0..N_MAX-1] de Ligne
n_lig,n_col : deux entiers
ALGORITHME :
pour n_lig parcourant [1..N_MAX] :
pour n_col parcourant [1..N_MAX] :
// produit de n_col par n_lig
table[n_lig-1][n_col-1] <-- n_lig * n_col;
1 2 3 4 5 6 7 8 9 10
2 4 6 8 10 12 14 16 18 20
3 6 9 12 15 18 21 24 27 30
4 8 12 16 20 24 28 32 36 40
5 10 15 20 25 30 35 40 45 50
6 12 18 24 30 36 42 48 54 60
7 14 21 28 35 42 49 56 63 70
8 16 24 32 40 48 56 64 72 80
9 18 27 36 45 54 63 72 81 90
10 20 30 40 50 60 70 80 90 100
Figure 5.1 – Tables de multiplication de 1 à 10
Equipe
Questions concernant le remplissage du tableau
1. Dans quelle case du tableau table se trouve le produit 1*1 ?
Organisation du travail Dans ce tp, vous avez à écrire une séquence de deux blocs de codes
distincts :
1. le premier initialise (remplit) un tableau en mémoire
2. le second affiche à l’écran le contenu du tableau stocké en mémoire
Il est fortement recommandé de ne tester qu’un bloc de code à la fois : affichage puis remplissage
ou remplissage puis affichage. Les binômes peuvent même effectuer le travail en parallèle et fusionner
les codes ensuite.
5.2 Affichage du tableau

On donne ci-dessous un algorithme pour afficher le tableau conformément à la figure 5.1, une fois
celui-ci rempli. On utilise les fonctions d’entrée/sortie suivantes :
— ecrire car(c) : affiche sans retour à la ligne le caractère de code ascii c.
— ecrire chn(s) : affiche sans retour à la ligne la chaine de caractères s.
— ecrire int(e) : affiche sans retour à la ligne la forme décimale de l’entier e.
— a la ligne() : provoque un retour à la ligne
LEXIQUE :
N_MAX : l’entier 10
ESPACE : le caractère ’ ’ // code ascii 32
BARRE : le caractère ’|’ // code ascii 124
TIRETS : le caractère ’---’ // code ascii 45
Ligne : le type tableau sur [0..N_MAX-1] d?entiers
table : le tableau sur [0..N_MAX-1] de Ligne
n_lig,n_col : deux entiers
mult : un entier
ALGORITHME :
pour n_lig parcourant [0..N_MAX-1] :
pour n_col parcourant [0..N_MAX-1] :
ecrire_car(BARRE);
mult <-- table[n_lig][n_col];
si mult < 100 alors ecrire_car(ESPACE);
si mult < 10 alors ecrire_car(ESPACE);
ecrire_int(mult);
ecrire_car(BARRE);
a_la_ligne();
répéter N_MAX fois :
ecrire_car(BARRE);
ecrire_chn(TIRETS);
ecrire_car(BARRE);
a_la_ligne();
Equipe
Traduire en langage d’assemblage cet algorithme, récupérer le fichier tabmult.s et compléter la
partie affichage. Tester cette partie, pour le tableau évidemment pour l’instant vide ; c’est-à-dire que
l’affichage que vous devez observer est le même que celui de la figure 5.1 mais avec des zéros.
Pour la traduction des fonctions d’entrées-sorties utiliser les fonctions suivantes définies dans le
fichier es.s :
— EcrChn pour implémenter ecrire car et ecrire chn. Pour écrire un caractère sans retour à
la ligne déclarer le caractère comme chaı̂ne.
— EcrNdecim32 pour implémenter ecrire int.
— AlaLigne pour implémenter a la ligne.
5.3 Remplissage du tableau

Il s’agit maintenant de traduire en langage d’assemblage l’algorithme de remplissage du tableau
donné au paragraphe 5.1.
Transformer cet algorithme dans une forme adaptée à la traduction en langage d’assemblage
(i.e. suppression des constructions pour).
Dans un premier temps, on garde telle quelle l’écriture de l’accès à un élément du tableau
(table[n lig][n col).
Pour réaliser la multiplication de deux entiers positifs vous pouvez utiliser des additions successives
selon l’algorithme suivant :
LEXIQUE :
mult, a et b : trois entiers positifs ou nuls
ALGORITHME :
mult <-- 0;
répéter a fois : mult <-- mult + b;
Votre compte-rendu comportera cette version intermédiaire de la traduction.
5.3.1 Codage d’un tableau à 2 dimensions

Pour stocker en mémoire un tableau à 2 dimensions, on peut le transformer en un tableau à une
dimension en rangeant les lignes du tableau, les unes après les autres. Chaque ligne est une suite de
cases contenant chacune un élément du tableau.
Par exemple, un tableau avec 4 lignes et 6 colonnes pourra être représenté par un tableau de
4*6=24 cases.
table : e00
e01
e02
e00 e01 e02 e03 e04 e05 e03
e10 e11 e12 e13 e14 e15 e04
e20 e21 e22 e23 e24 e25 e05
e30 e31 e32 e33 e34 e35 e10
e11
...
e35
questions
1. table étant l’adresse de début du tableau (i.e. du premier élément), exprimer la formule du
donne l’adresse de table[x][y] en fonction de table, x et y ?.
Equipe
2. Donner le langage d’assemblage correspondant à la ligne suivante (calcul d’adresse, puis écriture
de la valeur en mémoire) : table[x][y] <-- valeur.
5.3.2 Codage du programme de multiplication (version 1)

En rassemblant les différents algorithmes que vous avez traduits, vous avez maintenant une ver-
sion complète et vous pouvez compléter le fichier tabmult.s le compiler, l’exécuter et vérifier vos
résultats . . .
Pour vérifier que votre tableau est correctement rempli, vous pouvez utiliser gbd ou ddd pour
afficher le contenu de la mémoire à l’adresse debutTab. Vous pouvez aussi utiliser la partie affichage
si celle-ci a été complètement testée car dans le cas contraire vous n’êtes pas à l’abri d’un bug dans
cette première partie.
5.3.3 Codage du programme de multiplication (version 2)

Pour parcourir le tableau à 2 dimensions, on pourrait aussi parcourir le tableau à 1 dimension du
début à la fin, en utilisant une seule boucle. L’algorithme de remplissage du tableau peut alors être
récrit sans utiliser de multiplication.
questions
1. Donnez la nouvelle forme de l’algorithme complet.
2. Traduire cette version en langage d’assemblage. Reprenez la version initiale du fichier
tabmult.s, complétez-le avec la traduction de votre algorithme.
3. Compilez votre programme, exécutez le et vérifiez vos résultats . . .
Pour le compte-rendu :
les différentes lignes de vos algorithmes doivent apparaı̂tre de façon claire sous forme de
commentaire dans votre programme en langage d’assemblage. Vous donnerez aussi les
conventions d’implantation des différentes variables dans les registres
5.4 tabmult.s
@ Programme tabmult : Affiche les tables de multiplication de de 1 a 10
N_MAX= 10
.data
barre : .byte ’|’
.byte 0
espace : .byte ’ ’
.byte 0
tirets : .asciz "---"
debutTab: .skip N_MAX*N_MAX*4 @ adresse du debut du tableau
.text
.global main
main:
@ remplissage du tableau
@ a completer...
Equipe
@ affichage du tableau
@ a completer...
BAL exit
ptr_debutTab : .word debutTab

adr_barre : .word barre
adr_espace : .word espace
adr_tirets : .word tirets
Equipe
Chapitre 6
TP séances 8, 9 et 10 : Procédures,
fonctions et paramètres
6.1 Traitement des fichiers au format bitmap

Une image donnée au format bitmap peut recevoir des traitements spéciaux via l’utilisation de
plusieurs types d’algorithmes.
L’objectif de ces TP est de réaliser plusieurs fonctions en langage d’assemblage ARM capables de
traiter différemment une image donnée en entrée au format bitmap.
Pour faciliter votre tâche la consigne est d’utiliser des hauteurs et largeurs d’image multiples de 8
pixels.
En partant des exemples des sections suivantes, vous devez produire les fonctions qui réalisent les
effets ci-dessous sur l’image :
1. Négatif ;
2. Symétries comme dans la figure 6.1 ci-après ;
3. Rotations comme dans la figure 6.1 ci-après.
rot+90 rot−90
symetrie (miroir) axe V
symetrie H+V ou rot+/− 180

symetrie (miroir) axe H
Figure 6.1 – Exemples d’opérations de symétrie et rotation d’une image
Equipe
6.2 Négatif d’une image au format bitmap
Le premier objectif de ces TP est de réaliser un programme capable de produire un fichier au
format bitmap qui contienne le négatif de l’image donnée en entrée au format bitmap aussi.
Le programme principal écrit en C, negatif.c, est disponible ci-après, il fait appel à une procédure
écrite en langage d’assemblage dans le fichier util.s, que vous devez le compléter par la procédure
NEG et la fonction NON OCT décrites ci-dessous.
6.2.1 Spécifications de NEG et NON OCT

La procédure NEG(tt, n) transforme le tableau d’adresse tt en son négatif, n étant la taille du
tableau en nombre d’octets. Cette procédure est exportée vers le programme principal qui l’utilise.
NEG : procédure (tt: adresse d’un tableau d’octet, n: entier)

pour i de 0 à n-1 : tt[i] <-- not tt[i]
Les conventions de passage des paramètres sont : l’adresse du tableau est dans r0, la valeur de n
est dans r1.
La fonction NON OCT est utilisée par la procédure NEG pour calculer la négation bit à bit d’un octet.
Cette fonction est locale à ce fichier.
NON_OCT : fonction (x : un octet) --> un octet
Les conventions de passage du paramètre et du résultat sont : l’octet donnée est dans r4, l’octet
résultat est dans r5.
6.2.2 Consignes de compilation

Le fichier contenant une image exemple charlot.bm et le fichier contenant le programme principal
negatif.c sont disponibles sur le site de l’UE.
Un petit rappel pour compiler vos programmes :
arm-eabi-gcc -c -Wa,-gdwarf2 util.s

arm-eabi-gcc -c -g negatif.c
arm-eabi-gcc -o exec -g negatif.o util.o
arm-eabi-run exec
Le programme lit le fichier charlot.bm et produit le fichier resultat.bm. Pour afficher ces fichiers,
utiliser la commande bitmap (cf. le premier TP).
6.2.3 util.s
.text
.global NEG
@ NEG : procedure (tt: tableau d’octet, n: entier)

@ NEG(tt, n) transforme le tableau d’adresse tt en son negatif
@ n est la taille du tableau en nombre d’octets
@ adresse du tableau dans r0, n dans r1
NEG:
Equipe
@ a completer
@ NON_OCT : fonction (x : un octet) --> un octet

@ NON_OCT(x) est la negation bit a bit de l’octet x
@ donnee dans r4, resultat dans r5
NON_OCT:
@ a completer
6.2.4 negatif.c
/* transformation d’un image au format bitmap en son image negative
*
* le programme produit un fichier resultat.bm
*
* ce programme fait appel a la procedure NEG qui transforme
* un tableau de bits en sa negation bit a bit
*
*/
#include <stdio.h>
#include "charlot.bm"
/* NEG : procedure (tt : tableau d’octet, n : entier)

* NEG(tt) transforme le tableau d’adresse tt en son negatif
* n est la taille du tableau en nombre d’octets
*/
extern void NEG (unsigned char *ptr_tab, int n);
int main(int argc, char *argv[]) {

int nboctets, i, nblignes, j;
FILE *fich_res;
/* un pixel = 1 bit d’ou 1 octet vaut pour 8 pixels

* et nombre d’octets de l’image = (longueur * largeur) / 8 */
nboctets = (charlot_width*charlot_height) >> 3;
printf ("Calcul du negatif de l’image\n");
/* ****************************************** */
/* appel d’une procedure ecrite en assembleur */
/* ****************************************** */
NEG (charlot_bits, nboctets);
/* ****************************************** */
/* version en C */
Equipe
/*
for (i=0;i<nboctets;i++) {
charlot_bits[i] = ~charlot_bits[i];
}
*/
/* ****************************************** */
printf ("Production du fichier resultat.bm\n");

if ( (fich_res = fopen("resultat.bm", "w")) == NULL ) {
printf ("%s : impossible d’ouvrir le fichier %s\n",
argv[0], "resultat.bm");
exit(1);
}
fprintf (fich_res, "#define charlot_width %d\n", charlot_width);

fprintf (fich_res, "#define charlot_height %d\n", charlot_height);
fprintf (fich_res, "static unsigned char charlot_bits[] = {\n");
nblignes = nboctets / 12; /* on ecrit des lignes de 12 octets */
/* les nb-1 premieres lignes */
for (j=0; j < nblignes; j++) {
for (i=0; i<12; i++) {
fprintf (fich_res, "0x%x, ", charlot_bits[(j*12) + i]);
};
fprintf (fich_res, "\n");
}
/* la derniere ligne (peut etre moins de 12 octets) */
for (i=0; i < (nboctets - (nblignes*12) -1) ; i++) {
fprintf (fich_res, "0x%x, ", charlot_bits[(nblignes*12)+i]);
}
/* le dernier n’est pas suivi d’une virgule */
fprintf (fich_res, "0x%x", charlot_bits[nboctets-1]);
fprintf (fich_res, "};\n");
fclose (fich_res);
6.3 Miroir vertical d’une image au format bitmap

Le code ci-après en langage C propose deux méthodes de calcul du symétrique d’un octet :
1. Avec une constante tableau préinitialisée (cf. tabsym.h) ;
2. Par des opérations bit à bit + décalage.
Adaptez le code main de la section précédente pour valider votre programme en langage d’assem-
blage ARM qui fait les algorithmes décrits ci-après en langage C.
6.3.1 symetrie.c
#include <stdio.h>
#include "commun.h"
#include "charlot.bm"
Equipe
#ifndef SYMTAB
void symetrie_octet (unsigned char *adresse) {
unsigned char octet;
octet = *adresse;
// echange de quartets adjacents

octet = (octet & 0xF0) >> 4 | (octet & 0x0F) <<4;
// echange de doublets adjacents
octet = (octet & 0xCC) >> 2 | (octet & 0x33) <<2;
// echange de bits adjacents
octet = (octet & 0xAA)>> 1 | (octet & 0x55) <<1;
*adresse = octet;
}
#else
#include "tabsym.h"
void symetrie_octet (unsigned char *adresse) {

unsigned char octet;
octet = *adresse;
octet = tabsym_octet[octet];
*adresse = octet;
}
#endif
void permuter_ligne (unsigned char *tab, unsigned int octets_par_ligne, unsigned int col) {
unsigned char tmp;
tmp = tab[octets_par_ligne -1 - col];

tab [octets_par_ligne -1 - col] = tab [col];
tab[col] = tmp;
}
void symetrie (unsigned char *image) {

unsigned int position;
unsigned int li,col;
// symetriser chaque octet

for (position = 0; position < height*octets_par_ligne_image; position++) {
symetrie_octet (image+position);
}
// symetrie verticale octet par octet
for (li=0;li<height;li++) {
for (col=0; col<octets_par_ligne_image/2;col++)
permuter_ligne (image+li*octets_par_ligne_image, octets_par_ligne_image,col);
Equipe
}
}
6.3.2 commun.h
fndef _COMMUN_H_
#define _COMMUN_H_
#ifndef OCTETS_PAR_LIGNE_DU_FICHIER
#define OCTETS_PAR_LIGNE_DU_FICHIER 16
#endif
typedef unsigned char octet_fonc_t(unsigned char,unsigned char);
extern unsigned int nboctets;

extern unsigned char *adresse;
extern int i;
extern int position;
extern unsigned int octets_par_ligne_image;
unsigned char ou (unsigned char x, unsigned char y);

unsigned char etnot (unsigned char x, unsigned char y);
unsigned char ouex (unsigned char x, unsigned char y);
int afficher_chaine (char *format, char *chaine);

int afficher_entier (char *format, unsigned int entier);
void doinit();
void afficher_contenu (void);
/* neg_image : procedure (tt : tableau d’octet, n : entier)

* neg_image(tt) transforme le tableau d’adresse tt en son negatif
* n est la taille du tableau en nombre d’octets
*/
unsigned char neg_octet (unsigned char octet);

void neg_image (unsigned char *image, unsigned int n);
void symetrie (unsigned char *image);
void rectangle (unsigned int xhg,unsigned int yhg, unsigned int xbd, unsigned
int ybd,
octet_fonc_t f, unsigned char *image);
void traiter_point (unsigned char *image, unsigned int x, unsigned int y,

octet_fonc_t *f);
Equipe
#endif
6.3.3 tabsym.h
static const unsigned char tabsym_octet [256] = {
0x00,0x80,0x40,0xc0,0x20,0xa0,0x60,0xe0,0x10,0x90,0x50,0xd0,0x30,0xb0,0x70,0xf0,
0x0c,0x8c,0x4c,0xcc,0x2c,0xac,0x6c,0xec,0x1c,0x9c,0x5c,0xdc,0x3c,0xbc,0x7c,0xfc,
0x0a,0x8a,0x4a,0xca,0x2a,0xaa,0x6a,0xea,0x1a,0x9a,0x5a,0xda,0x3a,0xba,0x7a,0xfa,
0x0e,0x8e,0x4e,0xce,0x2e,0xae,0x6e,0xee,0x1e,0x9e,0x5e,0xde,0x3e,0xbe,0x7e,0xfe,
0x0d,0x8d,0x4d,0xcd,0x2d,0xad,0x6d,0xed,0x1d,0x9d,0x5d,0xdd,0x3d,0xbd,0x7d,0xfd,
0x0b,0x8b,0x4b,0xcb,0x2b,0xab,0x6b,0xeb,0x1b,0x9b,0x5b,0xdb,0x3b,0xbb,0x7b,0xfb,
0x0f,0x8f,0x4f,0xcf,0x2f,0xaf,0x6f,0xef,0x1f,0x9f,0x5f,0xdf,0x3f,0xbf,0x7f,0xff
};
Equipe
Chapitre 7
TP séance 11 : Etude du code produit

par le compilateur arm-eabi-gcc,
optimisations
Le code en langage d’assemblage ARM d’un programme en C peut être produit sans optimisation
par le compilateur gcc avec l’option -O0. Dans ce TP, nous allons observer ce qu’un compilateur peut
optimiser. Nous allons reprendre les mêmes programmes et codes du chapitre II.10, éventuellement
modifiés mais en les compilant avec un niveau d’optimisation important (option -O2).
Pour ce TP n’hésitez pas à faire d’autres essais que ceux qui sont proposés.
Un autre objectif du TP est de distinguer :
— ce qui est du domaine du “statique”, c’est-à-dire ce qui peut être calculé lors de la compilation,
— ce qui est du domaine du “dynamique”, c’est-à-dire ce qui ne peut être calculé que lors de
l’exécution.
7.1 Un premier exemple

Récupérez le programme écrit en langage C dans le fichier premier.c.
Compilez ce programme avec un bon niveau d’optimisations (option -O2) avec la commande sui-
vante : arm-aebi-gcc -O2 -S premier.c. Etudiez le code en langage d’assemblage ARM produit
dans le fichier premier.s et comparez avec le code étudié dans le chapitre II.10.
7.2 Programme avec une procédure qui a beaucoup de paramètres

7.2.1 Premier essai
On considère le programme contenu dans le fichier bcp param.c. Compilez ce programme avec la
commande : arm-aebi-gcc -O2 -S bcp param.c. Etudiez le programme produit dans bcp param.s
et comparez avec le code étudié dans le chapitre II.10.
7.2.2 Deuxième essai

Modifier le programme précédent de la façon suivante :
2
3 static long int Somme (long int a1, long int a2, long int a3, long int a4, long
int a5,
Equipe
4 long int a6, long int a7, long int a8, long int a9, long
int a10) {
6 long int y;
7
8 x1=a1+1; x2=a2+1; x3=a3+1; x4=a4+1; x5=a5+1;
9 x6=a6+1; x7=a7+1; x8=a8+1; x9=a9+1; x10=a10+1;
10 y = x1+x2+x3+x4+x5+x6+x7+x8+x9+x10;
11 return (y);
12 }
13
14 int main () {
15 long int z; long int u1, u2, u3, u4, u5, u6, u7, u8, u9, u10;
16
17 scanf ("%d", &u1);
18 scanf ("%d", &u2);
19 scanf ("%d", &u3);
20 scanf ("%d", &u4);
21 scanf ("%d", &u5);
22 scanf ("%d", &u6);
23 scanf ("%d", &u7);
24 scanf ("%d", &u8);
25 scanf ("%d", &u9);
26 scanf ("%d", &u10);
27 z = Somme (u1, u2, u3, u4, u5, u6, u7, u8, u9, u10);
28 printf("La somme des entiers vaut %d\n", z);
29 }
Compilez ce programme, étudiez le code produit, comparez avec la version précédente.
7.2.3 Troisième essai

Modifier le programme précédent de la façon suivante :
2
3 static long int Somme (long int a1, long int a2, long int a3, long int a4, long
int a5,
4 long int a6, long int a7, long int a8, long int a9, long
int a10) {
6 long int y;
7
8 x1=a1+1; x2=a2+1; x3=a3+1; x4=a4+1; x5=a5+1;
9 x6=a6+1; x7=a7+1; x8=a8+1; x9=a9+1; x10=a10+1;
10 y = x1+x2+x3+x4+x5+x6+x7+x8+x9+x10;
11 return (y);
12 }
13
14 int main () {
15 long int z; long int u;
16
17 scanf ("%d", &u);
18 z = Somme (1, 2, 3, 4, u, 6, 7, 8, 9, 10);
19 printf("La somme des entiers vaut %d\n", z);
20 }
Compilez ce programme, étudiez le code produit, comparez avec la version précédente.
Equipe
7.3 Les variables locales peuvent prendre beaucoup de place
Soit le programme contenu dans le fichier var pile.c. Compilez ce programme avec la commande :
arm-aebi-gcc -O2 -S var pile.c. Etudiez le programme produit dans var pile.s et comparez avec
le code étudié dans le chapitre II.10.
7.4 Le programme peut aussi aider ...

Reprendre le programme vu en TD II.10. et les réécritures de ce programme pour éliminer la double
boucle et tester l’efficacité des réécritures.
Chercher avec les options de compilations ou d’autres réécritures à améliorer le temps de calcul de
ce programme.
Programme initial :
2 #define NMax 1000000000
3
4 int main() {
5 int i,j,zero,tab[2]; i=NMax;zero=0;tab[0]=0;tab[1]=0;
6 for(i=NMax;i;i--) {
7 for(j=1;j>=0;j--) {
8 if (i&(1<<j)) {
9 tab[j]++;}
10 if (j==0) {
11 zero++;}}}
12 printf("%d - %d - %d\n",tab[0],tab[1],zero);
13 return;}
Equipe
Chapitre 8
TP séances 12 : Procédures et
paramètres
8.1 Application d’une fonction à tous les éléments d’un tableau

On considère le lexique suivant :
. Ent8 : entier sur [-128 .. + 127]
. NMAX : constante de type entier >= 0 et <= 255
. EntN : entier sur [0 .. NMAX]
. TabEnt8 : tableau sur [0 .. NMAX - 1] d’entiers du type Ent8
. FoncMapEnt8 : adresse d’une fonction avec un paramètre du type Ent8 et un

retour du type Ent8 aussi
. saisir_tab : procédure avec deux paramètres des types : TabEnt8 et EntN

{
saisir_tab(t, n) : saisit le contenu des n premiers entiers du type Ent8
dans un tableau t
}
. afficher_tab : procédure avec deux paramètres des types : TabEnt8 et EntN

{
afficher_tab(t, n) : affiche le contenu des n premiers entiers du type Ent8
qui sont dans un tableau t
}
. map : procédure avec quatre paramètres des types : TabEnt8, EntN, TabEnt8 et FoncMapEnt8
{
map(t1, n, t2, f) : t1 est un tableau qui contient une séquence de n entiers
du type Ent8, déjà t2 est un tableau qui contient la séquence avec les résultats
du type Ent8 de la fonction f du type FoncMapEnt8 : [f(t1[0]), f(t1[1]), ..., f(t1[n-1])]
}
On s’intéresse à la procédure map. Une réalisation en est donnée par l’algorithme suivant :
Equipe
map(t1, n, t2, f) :
i : entier du type EntN
i <- 0
tant que i != n
t2[i] <- f(t1[i])
i <- i + 1
On se propose de coder cette procédure en langage d’assemblage. On convient que :

— l’adresse du tableau t1 est passée dans le registre r0
— la taille n de la séquence est passée dans le registre r1
— l’adresse du tableau résultat t2 est passée dans le registre r2
— l’adresse de la fonction f est passée dans le registre r3
D’autre part, pour l’appel de la fonction f on convient que :
— l’entier donné est passé dans le registre r3
— le résultat calculé par la fonction est produit dans le registre r4
Note : Pour appeler une fonction dont l’adresse est dans un registre on utilise l’instruction ARM BLX
(Cf. paragraph 2.1.6).
De même, la convention d’appel des procédures saisir tab et afficher tab est la suivante :
— l’adresse du tableau t est passée dans le registre r0
— le nombre n d’éléments à afficher est passé dans le registre r1
Exercice 1 :
1. Traduire l’algorithme en langage d’assemblage Arm : compléter la définition de la procédure
map (fichier map.s, cf. annexe I).
2. Compléter le corps de la procédure principale main du fichier essai-map.s (cf. annexe III) : vous
devez ajouter aux endroits voulus de ce fichier deux appels à la procédure map et pour chacun
d’eux un appel à la procédure auxillaire afficher tab (fichier gestion tab.s, cf. annexe VI).
La procédure map sera invoquée une première fois avec la fonction plus un comme un paramètre
telle que : plus un(x) = x+1 et une seconde fois avec la fonction carre telle que : carre(x) = x2
(fichier fg.s, cf. annexe II).
3. Compilez et testez le programme (faites un fichier Makefile permettant d’utiliser la commande
make pour compiler le programme).
8.2 Réduction d’un tableau à une valeur

Pn−1
8.2.1 Calcul de i=0 T [i]
On ajoute les éléments suivants dans le lexique de la question précédente :
. Ent32 : entier naturel sur 32 bits
. FoncRedEnt8 : adresse d’une fonction avec un paramètre du type Ent8 et un

retour du type Ent32
. red : fonction avec quatre paramètres des types TabEnt8, EntN, Ent8 et
FoncRedEnt8 et un retour du type Ent32
{
si n > 0 : red(t, n, vi, g) = g( ... (g(g(g(vi, t[0]), t[1]), t[2]), ..., t[n - 1]) ... )
si n = 0 : red(t, 0, vi, g) = vi
Equipe
}
Pn−1
Si g est la fonction somme telle que : somme(x, y) = x + y, alors red(t, n, 0, somme) = i=0 t[i].
Une réalisation de la fonction red est donnée par l’algorithme suivant :
red(t, n, vi, g) :
i : entier du type EntN
acc : entier du type Ent32
i <- 0
acc <- vi
tant que i != n
acc <- g(acc, t[i])
i <- i + 1
retour acc
Pour coder cette fonction en langage d’assemblage, on convient que :

— l’adresse du tableau t est passée dans le registre r0
— la taille n de la séquence à traiter est passée dans le registre r1
— la valeur initiale du calcul est passée dans le registre r2
— l’adresse de la fonction g est passée dans le registre r3
D’autre part, pour l’appel de la fonction g on convient que :
— les données sont passées dans les registres r0 et r1
Exercice 2 :
1. Traduire l’algorithme en langage d’assemblage Arm : compléter la définition de la fonction red
(fichier red.s, cf. annexe IV).
2. Compléter le corps de la procédure principale main du fichier essai-red.s (cf. annexe V). Vous
devez ajouter aux endroits voulus de ce fichier un appel à la fonction red ainsi qu’un appel à
l’une des deux procédures auxillaires EcrZdecimal32 ou EcrZdecim32 (cf. fichier es.s).
La fonction red sera invoquée avec la fonction somme comme un paramètre telle que :
somme(x, y) = x + y (fichier fg.s, cf. annexe II).
3. Compilez et testez le programme.
Qn−1
8.2.2 Calcul de i=0 T [i]
Exercice 3 :
1. Quels
Qn−1 sont-ils les paramètres à passer à la fonction red pour effectuer le calcul du produit
i=0 T [i] ?
2. Quelle est la fonction qui remplace g de l’exercice précédent ?

3. Ajoutez au programme main de l’exercice précédent une invocation de la fonction red permet-
tant de réaliser ce calcul.
4. Compilez et testez le programme modifié.
Equipe
8.3 Passage de paramètres par la pile
Exercice 4 :
On veut réaliser une nouvelle version de la procédure map, ou de la fonction red, en utilisant cette
fois-ci le passage de paramètres par la pile plutôt que par les registres. Choisissez une organisation
de la pile appropriée pour le passage des paramètres (le schéma correspondant sera à inclure dans le
compte-rendu du TP), puis réalisez une nouvelle version du programme (dans les fichier map2.s et
essai-map2.s, ou red2.s et essai-red2.s, par exemple).
Annexe I : le fichier map.s

@ procedure map
@ parametres : A COMPLETER
@ algorithme : A COMPLETER
@ allocation des registres : A COMPLETER
.text
.global map
map:
@@@@@@@@@@@@@
@ A COMPLETER
@@@@@@@@@@@@@
Annexe II : le fichier fg.s

.global plus_un, carre
.global somme, produit
.text
@ fonction plus_un : incremente l’entier passe en parametre
@ r3 : donnee
@ r4 : resultat
plus_un: add r4, r3, #1
mov pc, lr
@ fonction carre : eleve au carre l’entier passe en parametre

@ r3 : donnee
@ r4 : resultat
carre: sub sp, sp, #4
str lr, [sp]
sub sp, sp, #4
str r0, [sp]
sub sp, sp, #4
str r1, [sp]
sub sp, sp, #4
str r2, [sp]
mov r0, r3
mov r1, r3
bl mult
mov r4, r0
ldr r2, [sp]

add sp, sp, #4
ldr r1, [sp]
Equipe
add sp, sp, #4
ldr r0, [sp]
add sp, sp, #4
ldr lr, [sp]
add sp, sp, #4
mov pc, lr
@ fonction somme : ajoute les deux entiers passes en parametre

@ r0, r1 : donnees
@ r2 : resultat
somme: add r2, r0, r1
mov pc, lr
@ fonction produit : multiplie les deux entiers passes en parametre

@ r0, r1 : donnees
@ r2 : resultat
produit:
@@@@@@@@@@@@@
@ A COMPLETER
@@@@@@@@@@@@@
Annexe III : le fichier essai-map.s

.set NMAX, 10 @ nombre d’elements
.data
invite1: .asciz "Saisir une sequence de "
invite2: .asciz " entiers :"
afftab1: .asciz "Sequence donnee S :"
afftab2: .asciz "map(S, plus_un) :"
afftab3: .asciz "map(S, carre) :"
tab1: .skip NMAX @ tableau de NMAX octets
tab2: .skip NMAX @ tableau de NMAX octets
.text
.global main
@ procedure principale
main:
@ saisir la sequence donnee
ldr r1, adr_invite1
bl EcrChn
mov r1, #NMAX
bl EcrNdecim32
ldr r1, adr_invite2
bl EcrChaine
ldr r0, adr_tab1
mov r1, #NMAX
bl saisir_tab
@ afficher la sequence donnee

bl AlaLigne
ldr r1, adr_afftab1
bl EcrChaine
ldr r0, adr_tab1
mov r1, #NMAX
Equipe
bl afficher_tab
@ appel de la procedure map(tab1, NMAX, tab2, plus_un)

@@@@@@@@@@@@@
@ A COMPLETER
@@@@@@@@@@@@@
@ afficher la sequence resultat

bl AlaLigne
ldr r1, adr_afftab2
bl EcrChaine
@@@@@@@@@@@@@
@ A COMPLETER
@@@@@@@@@@@@@
@ appel de la procedure map(tab1, NMAX, tab2, carre)

@@@@@@@@@@@@@
@ A COMPLETER
@@@@@@@@@@@@@
@ afficher la sequence resultat

bl AlaLigne
ldr r1, adr_afftab3
bl EcrChaine
@@@@@@@@@@@@@
@ A COMPLETER
@@@@@@@@@@@@@
@ fin du programme principal

bal exit
@ relais vers la zone data

adr_invite1:
.word invite1
adr_invite2:
.word invite2
adr_afftab1:
.word afftab1
adr_afftab2:
.word afftab2
adr_afftab3:
.word afftab3
adr_tab1:
.word tab1
adr_tab2:
.word tab2
@ relais vers la zone text

adr_plus_un:
.word plus_un
adr_carre:
.word carre
Annexe IV : le fichier red.s

.text
Equipe
@ fonction red
@ parametres : A COMPLETER
@ algorithme : A COMPLETER
red:
@@@@@@@@@@@@@
@ A COMPLETER
@@@@@@@@@@@@@
Annexe V : le fichier essai-red.s

.set NMAX, 10 @ nombre d’elements
.data
invite1: .asciz "Saisir une sequence de "
invite2: .asciz " entiers :"
afftab: .asciz "Sequence donnee S :"
affres1: .asciz "red(S, somme) = "
tab : .skip NMAX @ tableau de NMAX octets
var_somme: .byte 0
.text
.global main
@ procedure principale
main:
@ saisir la sequence donnee
ldr r1, adr_invite1
bl EcrChn
mov r1, #NMAX
bl EcrNdecim32
ldr r1, adr_invite2
bl EcrChaine
ldr r0, adr_tab
mov r1, #NMAX
bl saisir_tab
@ afficher la sequence donnee

bl AlaLigne
ldr r1, adr_afftab
bl EcrChaine
mov r1, #NMAX
bl afficher_tab
@ appel de la fonction red(tab, NMAX, 0, somme)

@@@@@@@@@@@@@
@ A COMPLETER
@@@@@@@@@@@@@
@ afficher le resultat
bl AlaLigne
ldr r1, adr_affres1
bl EcrChn
@@@@@@@@@@@@@
@ A COMPLETER
@@@@@@@@@@@@@
Equipe
@ fin du programme principal
bal exit
@ relais vers la zone data

adr_invite1:
.word invite1
adr_invite2:
.word invite2
adr_afftab:
.word afftab
adr_affres1:
.word affres1
adr_tab:
.word tab
adr_var_somme:
.word var_somme
@ relais vers la zone text

adr_somme:
.word somme
Equipe
Annexe VI : le fichier gestion tab.s
.data
entier: .byte 0 @ entiers de la sequence
.text
.global saisir_tab, afficher_tab
@ procedure saisir_tab : saisit une sequence d’entiers

@ r0 = T : adresse de debut du tableau contenant la sequence
@ r1 = N : nombre d’elements de la sequence
@ algorithme : i parcourant 0 .. N - 1 : Lire8(T[i])
saisir_tab:
sub sp, sp, #4 @ sauvegarde adresse de retour
str lr, [sp]
sub sp, sp, #4 @ sauvegarde temporaires
str r1, [sp]
sub sp, sp, #4
str r2, [sp]
sub sp, sp, #4
str r5, [sp]
sub sp, sp, #4
str r6, [sp]
mov r5, #0 @ indice dans le tableau

mov r6, r1 @ nombre d’elements
tantque1:
cmp r5, r6
beq fintq1
ldr r1, adr_entier @ lire un entier
bl Lire8
ldrb r2, [r1]
strb r2, [r0, r5] @ le ranger dans le tableau
add r5, r5, #1 @ octet suivant
bal tantque1
fintq1:
ldr r6, [sp] @ restauration temporaires
add sp, sp, #4
ldr r5, [sp]
add sp, sp, #4
ldr r2, [sp]
add sp, sp, #4
ldr r1, [sp]
add sp, sp, #4
ldr lr, [sp] @ restauration adresse de retour
add sp, sp, #4
mov pc, lr @ retour a l’appelant
adr_entier:
.word entier
@ procedure afficher_tab : affiche une sequence d’entiers

@ r0 = T : adresse de debut du tableau contenant la sequence
@ r1 = N : nombre d’elements de la sequence
@ algorithme : i parcourant 0 .. N - 1 : EcrZdecimal8(T[i])
Equipe
afficher_tab:
sub sp, sp, #4 @ sauvegarde adresse de retour
str lr, [sp]
sub sp, sp, #4 @ sauvegarde temporaires
str r1, [sp]
sub sp, sp, #4
str r5, [sp]
sub sp, sp, #4
str r6, [sp]
sub sp, sp, #4
str r7, [sp]
@ corps de la procedure
mov r5, #0 @ indice dans tableau
mov r6, r0 @ adresse de debut
mov r7, r1 @ taille du tableau
tantque2:
cmp r5, r7
beq fintq2
ldrb r1, [r6, r5] @ on recupere l’octet courant
bl EcrZdecim8 @ qui est imprime
mov r1, #’ ’
bl EcrCar @ en le separant du suivant par un espace
add r5, r5, #1 @ octet suivant
bal tantque2
fintq2:
bl AlaLigne
ldr r7, [sp] @ restauration temporaires
add sp, sp, #4
ldr r6, [sp]
add sp, sp, #4
ldr r5, [sp]
add sp, sp, #4
ldr r1, [sp]
add sp, sp, #4
ldr lr, [sp] @ restauration adresse de retour
add sp, sp, #4
mov pc, lr @ retour a l’appelant
Equipe
Quatrième partie
Annexes
Equipe
Chapitre 1
Annexe I : Codage ASCII des

caractères
Dec Hex Char Dec Hex Char Dec Hex Char Dec Hex Char
0 00 NUL 32 20 SPACE 64 40 @ 96 60 ‘
1 01 SOH 33 21 ! 65 41 A 97 61 a
2 02 STX 34 22 ” 66 42 B 98 62 b
3 03 ETX 35 23 # 67 43 C 99 63 c
4 04 EOT 36 24 $ 68 44 D 100 64 d
5 05 ENQ 37 25 % 69 45 E 101 65 e
6 06 ACK 38 26 & 70 46 F 102 66 f
7 07 BEL 39 27 ’ 71 47 G 103 67 g
8 08 BS 40 28 ( 72 48 H 104 68 h
9 09 HT 41 29 ) 73 49 I 105 69 i
10 0A LF 42 2A * 74 4A J 106 6A j
11 0B VT 43 2B + 75 4B K 107 6B k
12 0C FF 44 2C , 76 4C L 108 6C l
13 0D CR 45 2D - 77 4D M 109 6D m
14 0E SO 46 2E . 78 4E N 110 6E n
15 0F SI 47 2F / 79 4F O 111 6F o
16 10 DLE 48 30 0 80 50 P 112 70 p
17 11 DC1 49 31 1 81 51 Q 113 71 q
18 12 DC2 50 32 2 82 52 R 114 72 r
19 13 DC3 51 33 3 83 53 S 115 73 s
20 14 DC4 52 34 4 84 54 T 116 74 t
21 15 NAK 53 35 5 85 55 U 117 75 u
22 16 SYN 54 36 6 86 56 V 118 76 v
23 17 ETB 55 37 7 87 57 W 119 77 w
24 18 CAN 56 38 8 88 58 X 120 78 x
25 19 EM 57 39 9 89 59 Y 121 79 y
26 1A SUB 58 3A : 90 5A Z 122 7A z
27 1B ESC 59 3B ; 91 5B [ 123 7B {
28 1C FS 60 3C < 92 5C \ 124 7C |
29 1D GS 61 3D = 93 5D ] 125 7D }
30 1E RS 62 3E > 94 5E ˆ 126 7E ˜
31 1F US 63 3F ? 95 5F 127 7F DEL
Equipe
Chapitre 2
Annexe II : Entiers en base 2, types C
La figure 2.1 illustre les représentations d’entiers naturels et signés pour une taille de mot de 4 bits.
A chaque entier peut être associé un angle. Effectuer une addition revient à ajouter les angles cor-
respondant. Un débordement de produit au-delà d’un demi-tour en arithmétique signée ou d’un tour
complet en arithmétique naturelle.
n 2n
décimal hexa octal binaire décimal hexa commentaire
0 0 00 0000 1 1
1 1 01 0001 2 2
2 2 02 0010 4 4
3 3 03 0011 8 8
4 4 04 0100 16 10 un quartet = un chiffre hexa
5 5 05 0101 32 20
6 6 06 0110 64 40
7 7 07 0111 128 80
8 8 10 1000 256 100 un octet = deux chiffres hexa
9 9 11 1001 512 200
10 A 12 1010 1024 400 1Kb
11 B 13 1011 2048 800 2Kb
12 C 14 1100 4096 1000 4Kb
13 D 15 1101 8192 2000 8Kb
14 E 16 1110 16384 4000 16Kb
15 F 17 1111 32768 8000 32Kb
16 10 20 10000 65536 10000 64Kb
20 14 24 10100 1048576 100000 1Mb = 1Kb2 = 5 chiffres
30 1E 36 11110 ˜1.07 × 109 40000000 1Gb = 1Kb3
Les tableaux ci-dessus et ci-dessous récapitulent les principales puissances de 2 utiles, avec leur
représentation en hexadécimal et les puissances de 10 approchées correspondantes, ainsi que les types C
entiers de taille précise (utiliser la taille en octets pour les réservations de mémoire et les alignements).
types d’entier relatif taille types d’entier naturel

synonyme sur ARM 32 bits type bits octets : sizeof(type) type synonyme sur ARM 32 bits
char int8 t 8 1 uint8 t unsigned char
short int16 t 16 2 uint16 t unsigned short
int int32 t 32 4 uint32 t unsigned int
Equipe
Chapitre 3
Annexe III : fonction de multiplication
Voici une réalisation possible raisonnablement efficace de la fonction de multiplication :
@ Algorithme de multiplication par addition et decalage

@ Principe : pour chaque bit i de a a’ 1, ajouter b << i
@ unsigned int mult (unsigned int a, unsigned int b) {
@ unsigned int resultat=0;
@ while (a != 0) {
@ if ((a & 1) != 0) {// ajouter b si a_0 == 1
@ resultat = resultat + b;}
@ b = b << 1; a = a >> 1;}
@ return resultat; }
@ Convention d’appel :
@ en entree, a : r0 ; b : r1 ; parametre temporaire, resultat : r2;
@ valeur retour : r0 (attention le r0 en entree est ecrase’)
.text
.global mult
mult:
stmfd sp!, {r1,r2}
mov r2,#0
b ctq
tq: tst r0,#1 @ (a&1)
addne r2,r2,r1 @ ajouter b si a_0 == 1
mov r1,r1, LSL #1
mov r0,r0, LSR #1
ctq: cmp r0,#0
bne tq
mov r0,r2 @ return resultat
ldmfd sp!,{r1,r2}
mov pc,lr
Equipe
Chapitre 4
Annexe III : Spécification des fonctions

d’entrée/sortie définies dans es.s
@ fichier es.s
@ fonctions d’entrees sorties
@ AlaLigne :
@ retour a la ligne
@ EcrCar :
@ ecriture d’un caractère dont la valeur est dans r1
@ EcrChn :
@ ecriture de la chaine sans retour à la ligne dont l’adresse est dans r1
@ EcrChaine :
@ ecriture de la chaine dont l’adresse est dans r1
@ EcrHexa32 :
@ ecriture d’un mot de 32 bits en hexadécimal
@ la valeur a afficher est dans r1
@ EcrZdecimalf32 :
@ ecriture en decimal d’un entier relatif represente sur 32 bits
@ l’entier est dans r1
@ EcrZdecimal16 :
@ l’entier est dans les 16 bits de poids faibles de r1
@ EcrZdecimal8 :
@ attention : les bits 15 a 8 de r1 sont eventuellement modifies
@ EcrNdecimal32 :
@ ecriture en decimal d’un entier naturel represente sur 32 bits
@ l’entier est dans r1
@ EcrNdecimal16 :
Equipe
@ EcrNdecimal8 :
@ attention : les bits 15 a 8 de r1 sont mis a 0
@ Lire32 :
@ lecture d’un entier represente sur 32 bits
@ l’adresse de l’entier doit etre donnee dans r1
@ Lire16 :
@ Lire8 :
@ LireCar :
@ lecture d’un caractere tape au clavier
@ l’adresse du caractere (code en ascii) doit etre donnee dans r1
Equipe

Sujets T DTP

Transféré par

Droits d'auteur :

Formats disponibles

Sujets T DTP

Transféré par

Informations du document

Description originale:

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

Sujets T DTP

Transféré par

Droits d'auteur :

Formats disponibles

Université Grenoble Alpes (UGA)

UFR en Informatique, Mathématique et Mathématiques Appliquées (IM2AG)

Unité d’Enseignement INF401 aux Parcours INF et MIN :

Introduction aux Architectures

1 Environnement informatique pour les travaux pratiques 5

2 Langage machine et langage d’assemblage ARM 9

2 TD séance 2 : Représentation des nombres 26

3 TD séance 3 : Langage machine, codage des données 36

4 TD séance 4 : Codage des données (suite) 40

5 TD séances 5 et 6 : Codage des structures de contrôle 44

6 TD séance 7 : Fonctions : paramètres et résultat 48

7 TD séance 8 : Appels/retours de procédures, action sur la pile 54

8 TD séance 9 : Correction partiel 57

9 TD séance 10 : Paramètres dans la pile, paramètres passés par l’adresse 58

10 TD séance 11 : Etude du code produit par le compilateur arm-eabi-gcc, optimisa-

11 TD séance 12 : Organisation d’un processeur : une machine à pile 70

III Travaux Pratiques 76

1 TP séance 1 : Représentation des informations (ex. : images, programmes, entiers) 77

2 TP séance 2 : Codage et calculs en base 2 83

3 TP séances 3 et 4 : Codage des données 86

4 TP séance 5 : Codage de structures de contrôle et le metteur au point gdb 92

5 TP séances 6 et 7 : Parcours de tableaux 96

7 TP séance 11 : Etude du code produit par le compilateur arm-eabi-gcc, optimisa-

8 TP séances 12 : Procédures et paramètres 111

1 Annexe I : Codage ASCII des caractères 122

2 Annexe II : Entiers en base 2, types C 123

3 Annexe III : fonction de multiplication 124

Environnement informatique pour les

1.1 Connexion au serveur

Depuis un poste du DLST : utiliser un logiciel de connexion à distance (typiquement putty,

1.2 Emplacement des fichiers

1.3 Configuration de la session de travail

1.4 Démarrage d’une session de travail

1.5 TP1 : ressources disponibles

1.6 Quelques commandes utiles (rappels)

1.7 Commandes raccourcies

— armcc <nom du fichier source .c>

— armbuild <nom du fichier exécutable> <nom du fichier source> [<liste de fichiers .o à

— armrun <nom du fichier exécutable>

— armgdb <nom du fichier exécutable>

— armddd <nom du fichier exécutable>

— armdata <nom du fichier ”objet” .o>

— armdisas <nom du fichier ”objet” .o>

Langage machine et langage

2.1 Résumé de documentation technique ARM

Figure 2.1 – Registre d’état du processeur ARM

Les bits N, Z, C et V sont les codes de conditions arithmétiques, I et F permettent le masquage

2.1.2 Les instructions

2.1.3 Les codes de conditions arithmétiques

code mnémonique signification condition testée

Figure 2.2 – Codes des conditions arithmétiques

2.1.4 Description de l’instruction de chargement d’un registre

Figure 2.3 – Codage de l’instruction mov

Figure 2.4 – Codage de la partie opérande d’une instruction

Exemples d’utilisations de l’instruction mov

MOV r1, #42 @ r1 <-- 42

Les instructions arithmétiques et logiques ont pour syntaxe :

Figure 2.5 – Codage d’une instruction arithmétique ou logique