Exercice 1 : Générez un projet assembleur Exercice 2 : Transfert de

Execice chapitre 4 Le jeux d’instruction du Processeur ARM V5 Page 1
V1.0 © 2008, Labor d’informatique technique, E. Firouzi
Exercice 1 : Générez un projet assembleur
Générez dans l’environnement de développement CARME un projet assembleur. Le code, qui a été
généré est relativement simple (boucle infinie). Débuguez ce code avec le simulateur.
Exercice 2 : Transfert de donnée
Utilisez de nouveau le simulateur. Observez le comportement des valeurs des registres durant
l’exécution du programme.
Exercice 2a) L’instruction MOV
Exécutez les instructions MOV suivantes :
Chargez le registre r0 avec la valeur #100
Chargez le registre r0 avec r1
Chargez le registre r2 avec la valeur #10
Chargez le registre r1 avec la valeur #1 si le bit Z vaut 1 (exécution conditionnelle)
Chargez le registre r2 avec la valeur #1 si le bit Z vaut 0 (exécution conditionnelle)
Chargez le registre r0 avec r1, dont la valeur a été décalée de 3 bits vers la gauche (LSL)
Chargez le registre r0 avec r1, dont la valeur a été décalée de 1 bit vers la droite (LSR)
Chargez le registre r0 avec r1, dont la valeur a été rotée de 1 bit vers la droite (ROR)
Exercice 2b) L’instruction MVN
Chargez le registre r1 avec la valeur 0xFF
Chargez le registre r0 avec l’inverse de r1
Exercice 2c) Les instruction LDR et STR
Chargez le registre r5 avec 0xa0001000 (adresse de base pour cet exercice)
Chargez le registre r0 avec le contenu de la mémoire, qui se trouve à l’adresse 0xa0001000
Chargez le registre r0 avec le contenu de la mémoire, qui se trouve à l’adresse 0xa0001000 plus un
offset de 4
Chargez le registre r2 avec la valeur #8
Chargez le registre r0 avec le contenu de la mémoire, qui se trouve à l’adresse 0xa0001000 plus un
l’offset contenu dans le registre r2
Déposez la valeur #55 à l’adresse 0xa0001000
Exercice 2c) Les modes d’adressage
Observez pour toutes ces exercices le contenu de la mémoire à l’adresse 0xa0001000 et le contenu
du pointeur r5 !
Chargez le registre r5 avec 0xa0001000 (adresse de base pour l’exercice)
Registre r0 = [r5] + Offset #4 pre-index et write back
Chargez le registre r2 avec #4
Registre r0 = [r5+r2] pre-index et write back

Execice chapitre 4 Le jeux d’instruction du Processeur ARM V5 Page 2
V1.0 © 2008, Labor d’informatique technique, E. Firouzi
Registre r0 = [r5] + Offset #4 Post index
Registre r0 = [r5+(r2<<2)] Post index
Exercice 2e) L’instruction STM
Chargez le registre r5 avec 0xa0001000 (adresse de base pour l’exercice)
r0 = 0x11, r1 = 0x22 et r2 = 0x33
Stockez les registres r0 à r2 à partir de l’adresse 0xa0001000 de la manière suivante :
Increment after
Increment before
Decrement after
Decrement before
Exercice 2f) L’instruction SWP
Chargez le registre r5 avec 0xa0001000 (adresse de base pour l’exercice)
r0 = 0x11111111, r1 = 0x22222222
r0 = mem[r5], mem[r5] = r1
Exercice 2g) L’instruction MRS
Chargez la valeur du registre cpsr dans le registre r0 !
Quelles sont les valeurs des bits d’état ?
Quel est le mode de fonctionnement ?
Exercice 3 : Les instructions arithmétiques et logiques
Utilisez de nouveau le simulateur. Observez le comportement des valeurs des registres durant
l’exécution du programme
Exercice 3a) L’instruction ADD
Chargez les valeurs 100 et 10 respectivement dans r1 et r2
r0 = r1 + r2
r0 = r1 + (4 * r2)
r0 = r1 + r2 + Carry
Exercice 3b) L’instruction SUB
r0 = r1 - r2
r0 = r1 - (2 * r2)
r0 = -r2
r2 = 2
Décrémentez r2, quelles est la valeur des bits d’état ?
Décrémentez encore r2, quelles est la valeur des bits d’état ?

Execice chapitre 4 Le jeux d’instruction du Processeur ARM V5 Page 3
V1.0 © 2008, Labor d’informatique technique, E. Firouzi
Exercice 3c) Les dépassement de capacité avec les opérations arithmétiques
Chargez les valeurs 10 et 0x7FFFFFFF respectivement dans r1 et r2
r0 = r1 + r2 avec ADDS, comment se comportent les bits d’état et quel est le résultat ?
r0 = r1 + r2 avec QADD, quel est le résultat ?
Exercice 3d) L’instruction de multiplication
r2 = 0x800000001 et r3 = 0x100
r0 = r2 * r3, multiplication 32 bits
[r0,r1] = r2 * r3, multiplication 64 bits signée
[r0,r1] = r2 * r3, multiplication 64 bits non signée
Exercice 3e) L’instruction de multiplication et d’accumulation
r2 = 0x800000001, r3 = 0x100 et r4 = 0x55
r0 = r2 * r3 + r4
r0 = 0 et r1 = 0
Exécutez 2 fois une multiplication signée suivi d’une addition 64 bits
[r0,r1] = [r0,r1] + r2 * r3
Exercice 3f) L’instruction de comparaison
r0 = 10, r1 = 10
Comparez r0 avec r1 (CMP), comment les bits d’état se comportent-ils ?
Comparez r0 avec 9, comment les bits d’état se comportent-ils ?
Comparez r0 avec r1 de façon négative (CMN), comment les bits d’état se comportent-ils ?
Attribuez la valeur -10 à r1 et refaite cette comparaison ?
Exercice 3g) L’instruction de test
Attribuez les valeurs 8 et 1 respectivement à r0 et r1
Testez le bit 3 de r0 (TST), comment les bits d’état se comportent-ils ?
Testez le bit 2 de r0, comment les bits d’état se comportent-ils ?
Testez si le bit 3 de r0 est mis à un (TEQ), comment les bits d’état se comportent-ils ?
Testez si le bit 2 de r0 est mis à un, comment les bits d’état se comportent-ils ?
Exercice 3h) Les instructions logiques
Chargez r1 avec 0x33333333
Masquez le bit de poids plus faible de r1
Exécutez une opération OU entre r1 et 0x0C
Mettre le bit 12 de r1 à 1
Exécutez une opération OU exclusif entre r1 et 0xF0
Changez le bit 7 de r1 (toggle)
Effacez les 4 bits de poids plus faible de r1
Effacez le bit 6 de r1

Execice chapitre 4 Le jeux d’instruction du Processeur ARM V5 Page 4
V1.0 © 2008, Labor d’informatique technique, E. Firouzi
Exercice 3i) Les instruction de décalage
Chargez r1 avec 0xC0000001
r0 = r1 décalé vers la gauche logique de 2 bits, comment les bits d’état se comportent-ils ?
r0 = r1 décalé vers la droite logique de 2 bits, comment les bits d’état se comportent-ils ?
r0 = r1 décalé vers la droite arithmétique de 2 bits, comparez le résultat avec le résultat précédent ?
r0 = r1 roté vers la droite arithmétique de 2 bits
Exercice 4 : Les sauts de programme
Utilisez de nouveau le simulateur. Observez le comportement des valeurs des registres durant
l’exécution du programme
Exercice 4a) Les sauts de programmes inconditionnels
Programmez une boucle infinie, dans laquelle la valeur de r0 est systématiquement incrémentée !
Exercice 4b) La boucle
Programmez une boucle qui est exécutée 10 fois. A chaque itération, la valeur de r0 doit être
incrémentée !
Exercice 4c) La somme
Additionner toutes les valeurs, qui se trouvent dans la mémoire entre l’adresse 0xa0001000 et
0xa001010
Exercice 4d) Le produis scalaire
Définissez le produit scalaire entre deux vecteurs. Les vecteurs se situent respectivement aux adresses
0xa0001000 et 0xa0001100 et possèdent chacun 100 éléments.
En algèbre linéaire le produis scalaire de deus vecteurs
⎟
⎟
⎟
⎟
⎟
⎠
⎞
⎜
⎜
⎜
⎜
⎜
⎝
⎛
=⋅
n
x
x
x
xM
r2
1
et
⎟
⎟
⎟
⎟
⎟
⎠
⎞
⎜
⎜
⎜
⎜
⎜
⎝
⎛
=⋅
n
y
y
y
yM
r2
1
de dimension n es tune valeur réelle, qui obtenu par la somme des produits des composants du vecteur:
∑
=
⋅++⋅+⋅=⋅=⋅ n
innii yx...yxyxyxyx 11111
r
r
Exercice 4e) Sous routine
Une sous routine doit additionner les valeurs des registres r1 et r2 et retourner le résultat avec le
registre r0. Appelez la sous routine avec différentes valeurs de r1 et r2.