Assembleur ARM - Université Laval

GIF-1001
Cours 8, p.1
Etienne Tremblay
Ordinateurs, Structure
et Applications
GIF-1001
Université Laval, Hiver 2014
Cours 8, Assembleur ARM
ARM, MOV, LDR et ADD

GIF-1001
Cours 8, p.2
Contenu de la présentation
• Comme tout langage de programmation, l’assembleur ARM permet
d’effectuer les opérations suivantes:
• Déclarer des variables et leur affecter des valeurs
• Effectuer des opérations mathématiques et logiques
• Gérer la séquence des opérations avec des énoncés conditionnels
et des boucles
• Appeler des fonctions (diviser une tâche en sous-tâches)
• Gérer les évènements et les exceptions
• Cette présentation présente les deux premiers points. Les autres points
sont vus dans les cours qui suivent.
• De nombreux documents sont disponibles sur internet et présentent
l’assembleur ARM en détail (voir les références à la fin).

GIF-1001
Cours 8, p.3
L’assembleur: des instructions en mots
• Comme vu dans les cours précédents, le microprocesseur lit et exécute
des instructions. Chaque instruction, en mémoire, est constituée d’un
opcode et de paramètres qui dépendent de l’opcode.
• Il est donc possible d’écrire un programme en binaire si on sait comment
représenter les instructions avec des « 0 » et des « 1 ». Toutefois, le
processus est très pénible: qui voudrait écrire 0x23AB435F4EE7832FFA
pour effectuer l’opération « a = b + c »?
• Un assembleur est un programme qui traduit des mots, en anglais, dans
un fichier texte, en instructions. Il y a un mot, ou mnémonique, associé à
chaque instruction. Pour effectuer a = b + c, il est beaucoup plus facile
d’écrire:
• LDR R0, b ; Lire la variable b dans le registre R0
• LDR R1, c ; Lire la variable c dans le registre R1
• ADD R2, R0, R1 ; Registre R2 = R0 + R1
• STR R2, a ; Écrire le registre R2 dans la variable a

GIF-1001
Cours 8, p.4
Plus que des instructions en mots
• Le langage assembleur fait plus que traduire des mots/mnémoniques en binaire. Il
interprète aussi le texte de plusieurs façons:
• L’assembleur permet d’associer des mots du programmeur à des adresses
de mémoire.
• L’assembleur permet au programmeur de déclarer des variables et il
gère l’adresse de ces variables à travers les instructions du programme.
• L’assembleur permet au programmeur d’identifier des fonctions ou des
sections de codes avec des étiquettes (labels). Lorsque l’assembleur
décode un appel de fonction ou un branchement (saut) dans le
programme, il remplace les étiquettes par les adresses ou
déplacements (offset) appropriées.
• L’assembleur supporte des directives qui lui disent comment placer le code
en mémoire, comment gérer plusieurs fichiers, comment précompiler le code
–modifier le code avant de le traduire en binaire-, et plus. Les directives sont
des mots réservés qui ne génèrent pas de code en binaire, mais dirige la
création du code exécuté.
• L’assembleur permet d’insérer des commentaires dans le code, ce qui est
plus que nécessaire!

GIF-1001
Cours 8, p.5
Un exemple de programme
NAME main ;Nom du fichier/module
PUBLIC __iar_program_start ;Rend l'étiquette __iar_program_start disponible pour d'autres fichiers
SECTION .intvec : CODE (2) ;Le texte qui suit doit être assemblé dans la mémoire FLASH
CODE32 ;Les instructions qui suivent sont sur 32 bits
__iar_program_start ;Étiquette __iar_program_start: IAR commence le programme ici
B main ;Saut/Branchement vers l'étiquette main
;MaVarA = MaVarB + MaVarC
main LDR R0, MaVarB ;Lecture de mémoire, met MaVarB, 0x000000BB, dans R0
LDR R1, MaVarC ;Lecture de mémoire, met MaVarC, 0x000000CC, dans R1
ADD R2, R0, R1 ;R2 = R0 + R1
LDR R3,=MaVarA
STR R2, [R3] ;Écriture de mémoire, met R2 (MaVarB + MaVarC) dand MaVarA
B main ;Boucle infinie: retour à l'étiquette main
DATA ;Le texte qui suit doit être assemblé comme des constantes en FLASH
MaVarB DC32 0x000000BB ; Déclaration de MaVarB, sur 32 bits, valeur initiale = 0xBB
MaVarC DC32 0x000000CC ;Déclaration de MaVarC sur 32 bits, valeur initiale = 0xCC
SECTION `.noinit`:DATA(2) ;Variables en mémoire RAM!
MaVarA DS32 1 ;Déclaration de MaVarA comme une variable de 1*32 bits
END ;Fin du fichier/module