Assembleur (Arm)

ASSEMBLEUR (ARM)
1
Introduction (1)
Le cours d’architecture a illustré la conception d’un microprocesseur avec pour
outil de modélisation les FSM
 le mot placé dans IR (mot instruction) contient toute l’information sur le travail
a accomplir (+ opérandes)

Comment éviter l’écriture directe du mot instruction + opérande
(ex : E1A0 0271) pour coder un algorithme ?
 utilisation d’un mnémonique + opérandes réduisant l’effort de codage (ex :
movnes R0,R1,ROR R2 )
 le mnémonique + op n’est qu’une représentation différente de la même
information
 le microprocesseur n’utilise que la première représentation, c’est l’opération
d’assemblage qui traduit (c’est un compilateur qui génère un code du premier
type) le code assembleur en code machine

2
Introduction (2)
• L’ensemble (mnémonique + opérandes) constitue le langage ASSEMBLEUR
• Rem : pour un même microprocesseur  plusieurs langages assembleurs

possibles (ils se distinguent surtout par les directives, macros, les pseudo-
instructions …) (org 300), (a : ds.b 1), ( .data)
3
Points clefs du ARM
• Architecture load-store
• Instructions de traitement à 3 adresses
• Instructions conditionnelles (et branchement)
• Load et store multiples
• APCS (ARM Procedure Call Standard)
• En un cycle horloge: opération ALU+shift
• Interfaçage avec coproc. simplifié (ajout de registres, de type, …)
• Combine le meilleur du RISC et du CISC
• On le trouve dans la GBA, routeurs, Pockets PC, PDA, …
4
Que manipule-t-on ?
• Des registres
• Des adresses
• Des données
• Des instructions assembleurs (32 bits)
• Des directives
• Des pseudo-instructions
5
6
Des registres (mode User)
R0 16 Registres de 32 bits :
R1
R2
• R0-R10, R12 : généraux
R3 • R11 (fp) Frame pointer
R4
• R13 (sp) Stack pointer
R5
R6
• R14 (lr) Link register
R7 • R15 (pc) Program counter
R8
R9
R10
R11
R12
• Current Program Status Register
R13
R14
31 28 27 8 7 6 5 4 0
R15
N Z C V Pas utilisés IF T Mode
7
Des adresses et données
• 232 bytes de mémoire maxi
• Un word = 32 bits
• Un half-word = 16 bits
• Un byte = 8 bits
• Little endian (0x01AA  Ad+ AA 01)
• En hexa (0x0F), déc (15), bin (0b00001111)
8
Organisation mémoire
bit31 bit0
23 22 21 20
19 18 17 16
word16
15 14 13 12
Half-word14 Half-word12
11 10 9 8
word8
7 6 5 4
Byte6 Half-word14
3 2 1 0
byte3 byte2 byte1 byte0 adresse
9
Chaque
instruction est
codée sur 32 bits
(uniquement) !!!
10
Cond (toutes les instructions !)
11
OpCode (data processing)
12
Environnement de Prog.
.text  directive ldrb R0,te
.globl _main ldrb R1,boul
adc R0,R0,R1
_start:  label strb R0,gom
b _main
_main:
 code op opmrs R0,CPSR  opérandes
#attention à la taille des immédiats !! ldr mov pc,lr

R1,=0xDFFFFFFF
and R0,R0,R1
msr CPSR_f,R0 .align
mys: .space 1
#autre solution:pas de masquage, on force tous les bits
te: .space 1
# msr CPSR_f,#0xD
re: .space 1
ldrb R0,mys boul: .space 1
ldrb R1,re de: .space 1
adds R0,R0,R1 gom: .space 1
strb R0,de
.ltorg
.end
13
Environnement de Prog.
• En « cross-compilant » (outil GNU)

• En « linkant » (outil GNU)
• En simulant le processeur ARM
•  EmBest Ide
14
ARM-meste-2005 15
Les directives principales
Les directives sont des intructions pour l’assembleur (compilateur)
uniquement, elles commencent par « . ».
• .align: permet d’aligner en mémoire des données de types différents
.byte 0x55
.align sinon erreur à l’assemblage
.word 0xAA55EE11
• .ascii: permet de saisir des caractères (sans le NULL)
. ascii "JNZ" insère les octets 0x4A, 0x4E, 0x5A
• .asciz: comme .ascii mais insère à la fin le caractère NULL
. Asciz "JNZ" insère les octets 0x4A, 0x4E, 0x5A, 0x00
16
• .byte: déclare une variable type octet et initialisation
var1: .byte 0x11
var2: .byte 0x22,0x33
• .hword: déclare une variable type deux octets et initialisation
var3: .hword 0x1122
var4: .hword 0x44
• .word: déclare une variable type word (32bits) et initialisation
var5: .word 0x11223344
• .space: déclare une variable de taille quelconque (pas d’ initialisation)
var6: .space 10 réserve 10 octets
17
• .equ: associe une valeur à un symbol
.equ dix, 5+5
mov R3,#dix
• .global (ou .globl): l’étiquette (symbol) est visible globalement
.global _start _start est reconnue par le linker GNU
_start doit apparaître le code principal
• .text, .data, .bss : début de section text, data, bss (pour le linker)
• .end : fin du code source
• .ltorg : insère « ici » les constantes temporaires pour LDR =
ldr R1,=0x11111111
.ltorg
18
Pseudo-instructions
• NOP: No operation. En ARM est remplacé par MOV R0,R0
• LDR = : charge dans un registre une valeur immédiate ou une addresse

ldr R0,=42  mov R0, #42
ldr R1,=0x9988CDEF  ldr R1,[PC, #4] (pipeline !!!)
nop
.ltorg c’est ici que l’on trouve #0x9988CDEF
19
Pseudo-instructions
ldr R3,var3  ldr R3,[PC, #0]

charge dans R3 la valeur de var3
str R4,=var3  str R4,[PC, #0]

écrit en mémoire l’adresse de var3
charge l’adresse de var3
var3: .word 0xAAAAAAAA
.ltorg on trouve ici l’adresse de var3
REM: l’adresse de var3 est connue par l’assembleur, on peut mieux faire
20
Pseudo-instructions
• ADR : charge dans un registre l’adresse d’une variable (load/store)
adr R4, var5  add R4,PC,#4 (des fois sub !!!)
ldr R6,[R4]
nop
var5: .word 0xBBBBBBBB
PAS de .ltorg car l’adresse n’est pas en mémoire
REM: les valeurs immédiates sont limitées en taille,

si les variables sont dans .data  adrl ou ldr =
21
Module de décalage
Cela s’explique grâce au registre à décalage
-Le registre à décalage peut réaliser des

rotations à droite également
Opérand Opérand
e1 e 2 -Ne rajoute pas de cycle horloge
Registre-Ne s’utilise pas en tant qu’instruction

à décalage
-Permet de charger des constantes >8b
-Permet
C’est l’ALUdes MUL rapides
22
Module de décalage
En fait 12 bits disponibles

Ils sont décomposés en 4 bits de rotations et 8 bit de valeur immédiate
C’est à dire: 0-255 [0-0xFF] sur 8 bits et 0 rotation
Mais encore: 256, 260, …, 1020 [0x100-0x3FC]=[0x40-0xFF] ROR #30
0x3FC:
0xFF:
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 0 0
0xFF ror #1
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1
……. 0xFF ror #30

1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 0 0
23
Module de décalage
Et ainsi: 1024, 1040, …, 4080 [0x400-0xFF0]=[0x40-0xFF] ROR #28
4096, 4160, …, 16320 [0x1000-0x3FC0]=[0x40-0xFF] ROR #26
Ex:
mov R1, #0x1000  mov R1,#40,26 (pas une vraie syntaxe)
mov R2, #0xFFFFFFFF  mvn R2,#0
mov R2, #0x11111111  génère une erreur !!!
ldr R2, # 0x11111111  on a déjà vu, pas d’erreur
De plus LDR gère le registre à décalage

 on utilise si possible LDR pour charger des constantes
24
Module de décalage
Remplace un MUL avantageusement (MOV, ADD, SUB, RSB)
Ex1: R0 = R1*5
 R0 = R1+(R1*4)
 add R0, R1, R1 lsl #2
Ex2: R2 = R3*105
 R2 = R3*15*7
 R2 = R3*(16-1)*(8-1)  R2=(R3*16) - R3 puis R2=(R2*8)-R2
 rsb R2, R3, R3, lsl #4 puis rsb R2, R2, R2, lsl #3
N’est pas remplacé par l’Assembleur !!!
25
Instructions
On les rassemble en 3 groupes:

• Mouvements de données
• Opérations de traitements (arith. & log.)
• Instructions de contrôles
26
Instructions
Règles pour le traitement des données:
• Les opérandes sont 32 bits, constantes ou registres
• Le résultat 32 bits dans un registre
• 3 opérandes: 2 sources et 1 destination
• En signé ou non signé
• Peut mettre à jour les Flags (S)
• Le registre destination peut être un des registres sources
27
Instructions (Data Flow)
• Des LDR (indirect pour source), STR (indirect pour destination)
• Des MOV (constantes ou registre)
Les LDR sont souvent remplacés par des MOV (sauf adressage indirect)
LDR R1,R2  Error

MOV R1,R2  OK
LDR R1,=0x00FFFFFF  ldr r1, [pc, #4]
LDR R1,=1020  mov r1, #1020
LDR R1,[R2]  ldr r1, [r2]
28
En fait LDR/STR 
• LDR/STR simple (un seul registre)
• SWAP simple
• LDR/STR multiple (une liste de registres)
On utilise un registre contenant une adresse mémoire  registre de base

LDR R0,[R1]  On charge dans R0 le word (32bits) mem[R1]
STR R0,[R1]  On range dans mem[R1] (4 octets) R0
L’adresse est placée dans R1 avec un ADR ou LDR (voir directives)
29
Si R1 « pointe » (ADR R1,tab) sur une zone mémoire (vecteur, matrice)
Rem: une zone mémoire = vecteur, matrice, tableau, …
ADD R1, R1, #2  R1 pointe maintenant sur le prochain half-word

LDRH R0, [R1]  R0 reçoit le half-word : R0=mem16[R1]
On peut utiliser une pré-indexation (R1 est modifié avant le transfert):

LDRH R0, [R1,#2]  R0=mem16[R1+2]
 R1 mis à jour ??? Quelle syntaxe ???
30
? Rem: [R1,#4]
ne modifie pas R1
31
• Si on veut modifier R1 « automatiquement »  auto-incrémentation
LDRH R0, [R1,#2]!  R0=mem16[R1+2] puis R1=R1+2
• Si R1 pointe toujours sur le prochain élément à charger (pile)

 post-indexation
LDRH R0,[R1],#2  R0=mem16[R1] puis R1=R1+2
• Si l’offset est variable, un registre peut le remplacer

LDRH R0,[R1,R2]!  R0=mem16[R1+R2] puis R1=R1+R2
32
Résumé:
• LDR R0,[R1]  indirect

• LDR R0, [R1, #offset]  indirect pré-indexé
• LDR R0, [R1, #offset]!  indirect pré-indexé et auto-incrémenté
• LDR R0, [R1], #offset  indirect post-indexé et auto-incrémenté
• LDR R0, [R1, -R2]!  indirect pré-indexé et auto-incrémenté
• LDR R0, [R1], -R2  indirect post-indexé et auto-incrémenté
33
Encore plus complexe : format Word
34
Un LOAD/STORE particulier: SWAP
SWP R1,R2,[R3] 
1. R1 mémoire[R3]
2. mémoire[R3] R2
Pour échanger le contenu de la mémoire avec un registre

 SWP R2, R2, [R3]
35
Instructions Logiques
Elles opèrent bit à bit
(Elles sont très utilisées pour les E/S)
• Des instructions en soit:

-TST, TEQ (and et eor)  pas de destination, CPSR mis à jour
-AND, EOR, ORR, BIC (and not)
 destination, CPSR mis à jour si {S}
• Des instructions indirectes:

MOV R2,R1 LSL #5 , MOV R3,R4 LSR R6
 LSL, LSR, ASR, ROR, RRX
36
Instructions Logiques
• LSR: logical shift right
C
0
• ASR: arithmetic shift right

C
• ROR: rotate right

C
• RRX: rotate right extended

C
Un seul bit  remplacé par ROR #0
37
Instructions Arithmétiques
• Elles permettent l’addition, la soustraction, la multiplication
• Elles peuvent prendre en compte le flag C (retenue) et le mettre à jour
-ADD, ADC: addition, addition plus C

-SUB, SBC, RSB, RSC: soustraction, soustraction –NOT(C), inversée, …
SUBS R1,R2,R3  R1=R2-R3
RSBS R1,R2,R3  R1=R3-R2
-multiplications
38
Multiplications
• MUL rd,r1,r2  rd=r1*r2 sur 32bits

• MLA rd,r1,r2,r3 rd=r1*r2 + r3 sur 32bits
Signés:
• SMULL rdlo,rdhi,r1,r2  rd=r1*r2 sur 64bits
• SMLAL rdlo,rdhi,r1,r2,r3 rd=r1*r2 + r3 sur 64bits
NON Signés:
• UMULL rdlo,rdhi,r1,r2  rd=r1*r2 sur 64bits
• UMLAL rdlo,rdhi,r1,r2,r3 rd=r1*r2 + r3 sur 64bits
39
Un exemple de MLA:
MOV R11, #20

MOV R10, #0
LOOP: LDR R0,[R8], #4
LDR R1,[R9], #4
MLA R10,R0,R1,R10  R10=R10+R0*R1
SUBS R11,R11,#1  SUB et CMP car {S}
BNE LOOP
 C’est le produit scalaire de deux vecteurs
40
Les flags sont mis à jour avec {S}

 on peut également utiliser CMP (SUBS) ou CMN (ADDS)
CMP R1,#5  R1-5 : les flags sont mis à jour, résultat non stocké
• Utilisé avant une instruction conditionnelle (ARM)

• Utilisé avant un branchement conditionnel (B{cond} ou B{cond}L)
• Associé aux structures de contrôles
REM: TST (and) et TEQ (eor) pour comparaisons logiques
41
Inst./struct. de contrôles
• Elles déroutent le cours normal du programme

• Basées sur le couple (CMP, B{cond})
• Tests complexes (CMP{cond}) (voir TD)
• Elles cassent le pipeline (peut mieux faire ?)
• Elles servent à réaliser
– Les alternatives (if, case)
– Les itérations (for, while, repeat)
– Les procédures (BL)  normalisation
42
If: CMP R0,R1  CMP Rn,<Operand2
If Then Else:
BHS Else
If R0 < R1
Then:
Then
B Endif
Else Else:
Endif:
43
Case Of:
Case R2 Of Case:
-2: mDeux: CMP R2,#-2 (remplacé par CMN R1,#2) !!
BNE mTrois
-3: B Endcase
mTrois: CMP R2,#-3
BNE Otherwise
Otherwise:
B Endcase
Otherwise:
Endcase: 44
While do:
While: CMP R3,R1  CMP Rn,<Operand2>
While R3  R1 BLT Endwhile  si Rn LT Operand2 en signé
do # BLO Endwhile  si Rn LO Operand2 en nonsigné
do:
B While
Endwhile:
45
For:
LDR R3,=nfin
For R3 = 1 to nfin For:
do
SUBS R3,R3,#1 décrémentation de 1

BNE For
Endfor:
46
Appels de procédures, les Piles
Les procédures sont appelées avec Branch + Link (BL)
Les paramètres sont passés par:

• Adresses (noms de variables)
• Par registres (taille et nombre limités)
• Par adresse dans des registres (nombre limité)
• Par adresse ou valeur dans la pile  notion de pile
47
.globl _start proc:

.globl _main ADD R3,R1,R2
_start: B _main MOV PC,LR

_main:
MOV R1,#2
MOV R2,#3
BL proc  branchement à proc et LR (R14)=PC-4 (Pipeline)
STR R3,res
Nombre de registres limité  utilisation des piles (C, JAVA)
48
LDR et STR n’utilisent qu’un seul registre
LDM et STM utilisent plusieurs registres
LDMIA R1,{R0,R2,R4} (r0=mem32[r1], r2=mem32[r1+4], r4=mem32[r1+8])
R4
R3
R2
R1 Adresse de base
R0
mémoi
re
De même
STMIA R1,{R0,R2,R4} (mem32[r1]=r0, mem32[r1+4]=r2, mem32[r1+8]=r4)
49
L’instruction LDMIA est en fait LDM + I + A
LDM : Load Multiple
I : Incrémentation de l’adresse de base
A: l’adresse de base est incrémentée après utilisation (offset temporaire)
Si LDMIA R1 !, {R2-R9} alors on charge 8 registres (32 octets) et l’offset est

définitif (R1=R1+32) après utilisation
Le I+A peut se remplacer par:
Increment-After LDMIA STMIA
Increment-Before LDMIB STMIB
Decrement-After LDMDA STMDA
Decrement-Before LDMDB STMDB
50
R9’ R9’ R5
R5 R1
STMIA r9!,{r0,r1,r5} R1 STMIB r9!,{r0,r1,r5} R0
R9 R0 R9
STMDA r9!,{r0,r1,r5} STMDB r9!,{r0,r1,r5}
R9 R5 R9
R5
R1
R1
R0
R9’ R0
R9’
51
Ces instructions permettent l’implémentation de Piles (PUSH et POP) :
• PUSH : STMIA
• POP: LDMDB
Le sommet de pile est un emplacement vide et on empile vers les add
A ou B ???  Pas si simple
• Dans la terminologie ARM, les instructions de piles sont des STM

STMIA  STMED (E: emplacement Empty; D: adresses Descending)
LDMIB  LDMED
• Et R13 (SP) est considéré comme le pointeur de pile
52
On obtient alors les couples (PUSH/POP) possibles avec:

• emplacement Empty (E),Full (F)
• adresses Descending (D),Ascending (A)
• STMFA/LDMFA
• STMFD/LDMFD
• STMEA/LDMEA
• STMED/LDMED
Ces piles sont utilisées pour le passage de paramètres aux procédures

avec normalisation (ARM Procedure Call Standard) ou non
53
Utilisation efficace des piles en appel de procédure :
– On passe les paramètres par la pile, ou les registres

– La procédure sauvegarde tous les registres de travail (le prog appelant ne voit
pas les changements)
– La procédure sauvegarde le LR (elle peut appeler une autre procédure)
– La procédure restaure les registres sauvegardés avant le retour
54
.globl _start
.globl _main
proc:
_start: B _main
_main: STMED R13!,{R1-R2,R14}
MOV R1,#2 LDR R1,[R13,#16]
MOV R2,#3 LDR R2,[R13,#20]
(A) STMED R13!,{R1,R2}
ADD R3,R1,R2
(B) BL proc
(F) ADD R13,R13,#8
(G) STR R3,res (C) LDMED R13!,{R1-R2,R14}
(D) MOV PC,R14
Rem: (C) et (D) peuvent être remplacé par:

LDMED R13!,{R1-R2,PC}
R13 (C) (B),(D) (A),(G) AD+

4 octets 4 octets 4 octets 4 octets R1 R2 R14 R1 R2
55
Appels de procédures,APCS (réduit)
Le APCS (ARM Procedure Call Standard) fournit un mécanisme standardisé
permettant d’associer des routines C, assembleur, …
En définissant:
• Restrictions sur l’utilisation des registres
• Convention d’utilisation de la pile
• Convention de passage de paramètres
• Structuration du contexte de la procédure dans la pile
Il existe plusieurs versions de APCS
56
Appels de procédures, APCS
Les registres prennent des noms particuliers:
R10 : SL (stack limit)
R11 : FP (frame pointer)
R12 : IP (scratch register)
R13 : SP (stack pointer)
R14 : LR (link register)
R15 : PC
Et R0-R3 : A1-A4 arguments de proc/registres de travails/résultats

R4-R9 : V1-V6 variable registre
57
La pile (et les différents registres) permet de conserver une structure d’appel
pour les appels imbriqués:
Sauvegarde PC Sauvegarde PC Sauvegarde PC Sauvegarde PC
LR LR LR LR
SP SP SP SP
FP FP FP FP
… … … …
Contexte p4 Contexte p3 Contexte p2 Contexte p1
58
Exemple .text
int somme(int x1, int x2, int x3, int x4, int x5) .global somme
{ return x1+x2+x3+x4+x5; } .type somme,function
somme: mov ip, sp
//extern int somme(int x1, int x2, int x3, int x4, int x5);
stmfd sp!, {fp, ip, lr, pc}
int __main() sub fp, ip, #4
{ somme(2,3,4,5,6); } sub sp, sp, #16
str r0, [fp, #-16]
str r1, [fp, #-20]
str r2, [fp, #-24]
.global __main str r3, [fp, #-28]
__main: mov ip, sp ldr r2, [fp, #-16]
stmfd sp!, {fp, ip, lr, pc} ldr r3, [fp, #-20]
sub fp, ip, #4 add r3, r2, r3
sub sp, sp, #4 ldr r2, [fp, #-24]
mov r3, #6 add r3, r3, r2
str r3, [sp, #0] ldr r2, [fp, #-28]
mov r1, #3 ldr r2, [fp, #4]
mov r3, #5 mov r0, r3
bl somme ldmea fp, {fp, sp, pc}
ldmea fp, {fp, sp, pc}
59
Restauration des registres
somme: mov ip, sp
SP(1) stmfd sp!, {fp, ip, lr, pc} SP(2)
(STMDB)
sub fp, ip, #4 FP(1)
.
.
.
FP(1) ldmea fp, {fp, sp, pc} SP(1)
(LDMDB)
SP(2) FP(1) SP(1) AD+

4 octets 4 octets 4 octets 4 octets FP IP (sp(1)) LR PC
60
.text str r1, [fp, #-20] add r3, r3, r2

.global somme str r2, [fp, #-24] ldr r2, [fp, #-28]
.type somme,function str r3, [fp, #-28] add r3, r3, r2
somme: mov ip, sp ldr r2, [fp, #-16] ldr r2, [fp, #4]
SP(3) stmfd sp!, {fp, ip, lr, pc} SP(4) ldr r3, [fp, #-20] add r3, r3, r2
sub fp, ip, #4 FP(2) add r3, r2, r3 mov r0, r3
sub sp, sp, #16 SP(5) ldr r2, [fp, #-24] ldmea fp, {fp, sp, pc} SP(3)
str r0, [fp, #-16]
__main: mov ip, sp mov r0, #2

SP(1) stmfd sp!, {fp, ip, lr, pc} SP(2) mov r1, #3
sub fp, ip, #4 FP(1) mov r2, #4
sub sp, sp, #4 SP(3) mov r3, #5
mov r3, #6 bl somme
str r3, [sp, #0] ldmea fp, {fp, sp, pc} SP(1)
SP(5) SP(4) FP(2) SP(3) SP(2) FP(1) SP(1)
R3so R2so R1so R0so FPso IPso LRso PCso R3ma Fpma IPma LRma PCma
61
.text str r1, [fp, #-20] add r2, r2, r3

.global somme str r2, [fp, #-24] ldr r3, [fp, #-28]
.type somme,function str r3, [fp, #-28] add r2, r2, r3
somme: mov ip, sp ldr r2, [fp, #-16] ldr r3, [fp, #4]
SP(3) stmfd sp!, {fp, ip, lr, pc} SP(4) ldr r3, [fp, #-20] str r2, [r3, #0]
sub fp, ip, #4 FP(2) add r2, r2, r3 ldmea fp, {fp, sp, pc} SP(3)
sub sp, sp, #16 SP(5) ldr r3, [fp, #-24]
str r0, [fp, #-16]
__main: mov ip, sp mov r0, #2

SP(1) stmfd sp!, {fp, ip, lr, pc} SP(2) mov r1, #3
sub fp, ip, #4 FP(1) mov r2, #4
sub sp, sp, #4 SP(3) mov r3, #5
sub r3, fp, #16 bl somme
str r3, [sp, #0] ldmea fp, {fp, sp, pc} SP(1)
Dans ce cas, on passe l’adresse du résultat !!! (5 arguments)

void somme(int x1, int x2, int x3, int x4, int *x) { *x= x1+x2+x3+x4; }
int __main() { int c; somme(2,3,4,5,&c); }
62
Procédures particulières
Les Exceptions et les Interruptions auxquelles on associe:
• Des modes particuliers (autres que normal user mode) privilégiés
• Des valeurs particulières des bits [4:0] du CPSR
• De nouveaux registres
Elles sont générées:

• Comme étant un résultat d’une instruction (SWI, instruction illégale, erreur
mémoire en FETCH)
• Par un effet de bord d’une instruction (erreur mémoire data, division par zéro)
• En réponse à un signal extérieure (reset, Fast Interrupt FIQ, Normal interrupt)
63
De nouveaux registres
64
Quand une exception est levée:
• Le mode système est modifié (fonction du type)
• PC est sauvegardé dans le R14 correspondant
• CPSR est sauvegardé dans un Save Processor Status Register
(SPSR)
• Utilise la notion de priorité
• Force le PC à l’adresse de l’exception correspondante (Branch)
Cette adresse est stockée dans un tableau d’adresses (vecteurs)

Le microprocesseur « détermine » quel vecteur pour quelle exception
(reset: premier vecteur du tableau donc 0x00000000, …)
65

Assembleur (Arm)

Transféré par

Droits d'auteur :

Formats disponibles

Assembleur (Arm)

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Assembleur (Arm)

Transféré par

Droits d'auteur :

Formats disponibles

ASSEMBLEUR (ARM)

• L’ensemble (mnémonique + opérandes) constitue le langage ASSEMBLEUR

• Rem : pour un même microprocesseur  plusieurs langages assembleurs

N Z C V Pas utilisés IF T Mode

#attention à la taille des immédiats !! ldr mov pc,lr

• En « cross-compilant » (outil GNU)

• LDR = : charge dans un registre une valeur immédiate ou une addresse

ldr R3,var3  ldr R3,[PC, #0]

str R4,=var3  str R4,[PC, #0]

PAS de .ltorg car l’adresse n’est pas en mémoire

REM: les valeurs immédiates sont limitées en taille,

-Le registre à décalage peut réaliser des

Registre-Ne s’utilise pas en tant qu’instruction

-Permet de charger des constantes >8b

En fait 12 bits disponibles

……. 0xFF ror #30

De plus LDR gère le registre à décalage

On les rassemble en 3 groupes:

LDR R1,R2  Error

On utilise un registre contenant une adresse mémoire  registre de base

L’adresse est placée dans R1 avec un ADR ou LDR (voir directives)

ADD R1, R1, #2  R1 pointe maintenant sur le prochain half-word

On peut utiliser une pré-indexation (R1 est modifié avant le transfert):

 R1 mis à jour ??? Quelle syntaxe ???

• Si R1 pointe toujours sur le prochain élément à charger (pile)

• Si l’offset est variable, un registre peut le remplacer

• LDR R0,[R1]  indirect

Pour échanger le contenu de la mémoire avec un registre

• Des instructions en soit:

• Des instructions indirectes:

• ASR: arithmetic shift right

• ROR: rotate right

• RRX: rotate right extended

Un seul bit  remplacé par ROR #0

-ADD, ADC: addition, addition plus C

• MUL rd,r1,r2  rd=r1*r2 sur 32bits

MOV R11, #20

 C’est le produit scalaire de deux vecteurs

Les flags sont mis à jour avec {S}

• Utilisé avant une instruction conditionnelle (ARM)

REM: TST (and) et TEQ (eor) pour comparaisons logiques

• Elles déroutent le cours normal du programme

SUBS R3,R3,#1 décrémentation de 1

Les procédures sont appelées avec Branch + Link (BL)

Les paramètres sont passés par:

.globl _start proc:

_start: B _main MOV PC,LR

Nombre de registres limité  utilisation des piles (C, JAVA)

Si LDMIA R1 !, {R2-R9} alors on charge 8 registres (32 octets) et l’offset est

STMIA r9!,{r0,r1,r5} R1 STMIB r9!,{r0,r1,r5} R0

STMDA r9!,{r0,r1,r5} STMDB r9!,{r0,r1,r5}

A ou B ???  Pas si simple

• Dans la terminologie ARM, les instructions de piles sont des STM

• Et R13 (SP) est considéré comme le pointeur de pile

On obtient alors les couples (PUSH/POP) possibles avec:

Ces piles sont utilisées pour le passage de paramètres aux procédures

Utilisation efficace des piles en appel de procédure :

– On passe les paramètres par la pile, ou les registres

Rem: (C) et (D) peuvent être remplacé par: