ASSEMBLEUR ARM 1 Introduction 1 Le cours darchitecture

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 : E 1 A 0 0271) pour coder un algorithme ? utilisation d’un mnémonique + opérandes réduisant l’effort de codage (ex : movnes R 0, R 1, ROR R 2 ) 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 pseudoinstructions …) (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) R 0 R 1 R 2 R 3 R 4 R 5 R 6 R 7 16 Registres de 32 bits : • R 0 -R 10, R 12 : généraux • R 11 (fp) Frame pointer • R 13 (sp) Stack pointer • R 14 (lr) Link register • R 15 (pc) Program counter R 8 R 9 R 10 R 11 R 12 • Current Program Status Register R 13 R 14 31 28 R 15 N Z C V 27 8 Pas utilisés 7 6 5 4 0 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 (0 x 01 AA Ad+ AA 01) En hexa (0 x 0 F), déc (15), bin (0 b 00001111) 8

Organisation mémoire bit 31 bit 0 23 22 21 20 19 18 17 16 13 12 word 16 15 14 Half-word 14 11 Half-word 12 10 9 8 5 4 word 8 7 6 Byte 6 Half-word 14 3 2 1 0 byte 3 byte 2 byte 1 byte 0 adresse 9

Chaque instruction est codée sur 32 bits (uniquement) !!! 10

Cond (toutes les instructions !) 11

Op. Code (data processing) 12

Environnement de Prog. _start: label . text directive. globl _main b _main: code op opmrs R 0, CPSR opérandes #attention à la taille des immédiats !! ldr R 1, =0 x. DFFFFFFF and R 0, R 1 msr CPSR_f, R 0 #autre solution: pas de masquage, on force tous les bits # msr CPSR_f, #0 x. D ldrb R 0, mys ldrb R 1, re adds R 0, R 1 strb R 0, de ldrb R 0, te ldrb R 1, boul adc R 0, R 1 strb R 0, gom mov pc, lr mys: te: re: boul: de: gom: . align. space 1. ltorg. end 13

Environnement de Prog. • • En « cross-compilant » (outil GNU) En « linkant » (outil GNU) En simulant le processeur ARM Em. Best 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 0 x 55. align sinon erreur à l’assemblage. word 0 x. AA 55 EE 11 • . ascii: permet de saisir des caractères (sans le NULL). ascii "JNZ" insère les octets 0 x 4 A, 0 x 4 E, 0 x 5 A • . asciz: comme. ascii mais insère à la fin le caractère NULL. Asciz "JNZ" insère les octets 0 x 4 A, 0 x 4 E, 0 x 5 A, 0 x 00 16

Les directives principales • . byte: déclare une variable type octet et initialisation var 1: . byte 0 x 11 var 2: . byte 0 x 22, 0 x 33 • . hword: déclare une variable type deux octets et initialisation var 3: . hword 0 x 1122 var 4: . hword 0 x 44 • . word: déclare une variable type word (32 bits) et initialisation var 5: . word 0 x 11223344 • . space: déclare une variable de taille quelconque (pas d’ initialisation) var 6: . space 10 réserve 10 octets 17

Les directives principales • . equ: associe une valeur à un symbol. equ dix, 5+5 mov R 3, #dix • . global (ou. globl): l’étiquette (symbol) est visible globalement . global _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 R 1, =0 x 1111. ltorg 18

Pseudo-instructions • NOP: No operation. En ARM est remplacé par MOV R 0, R 0 • LDR = : charge dans un registre une valeur immédiate ou une addresse ldr R 0, =42 mov R 0, #42 ldr R 1, =0 x 9988 CDEF ldr R 1, [PC, #4] (pipeline !!!) nop. ltorg c’est ici que l’on trouve #0 x 9988 CDEF 19

Pseudo-instructions var 3: ldr R 3, var 3 ldr R 3, [PC, #0] charge dans R 3 la valeur de var 3 str R 4, =var 3 str R 4, [PC, #0] écrit en mémoire l’adresse de var 3 charge l’adresse de var 3 . word. ltorg 0 x. AAAA on trouve ici l’adresse de var 3 REM: l’adresse de var 3 est connue par l’assembleur, on peut mieux faire 20

Pseudo-instructions • ADR : charge dans un registre l’adresse d’une variable (load/store) var 5: adr R 4, var 5 add R 4, PC, #4 (des fois sub !!!) ldr R 6, [R 4] nop. word 0 x. BBBB 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 Opérand e 1 Opérand e 2 Registre à décalage -Le registre à décalage peut réaliser des rotations à droite également -Ne rajoute pas de cycle horloge -Ne s’utilise pas en tant qu’instruction -Permet de charger des constantes >8 b C’est l’ALU -Permet des 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 -0 x. FF] sur 8 bits et 0 rotation Mais encore: 256, 260, …, 1020 [0 x 100 -0 x 3 FC]=[0 x 40 -0 x. FF] ROR #30 0 x 3 FC: 0 x. FF: 0 0 0 0 0 0 1 1 1 1 0 0 0 x. FF ror #1 0 0 0 0 0 0 1 1 1 1 ……. 0 x. FF ror #30 1 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 1 1 1 1 0 0 23

Module de décalage Et ainsi: 1024, 1040, …, 4080 [0 x 400 -0 x. FF 0]=[0 x 40 -0 x. FF] ROR #28 4096, 4160, …, 16320 [0 x 1000 -0 x 3 FC 0]=[0 x 40 -0 x. FF] ROR #26 Ex: mov mov ldr R 1, #0 x 1000 R 2, #0 x. FFFF R 2, #0 x 1111 R 2, # 0 x 1111 mov R 1, #40, 26 (pas une vraie syntaxe) mvn R 2, #0 génère une erreur !!! 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) Ex 1: R 0 = R 1*5 R 0 = R 1+(R 1*4) add R 0, R 1 lsl #2 Ex 2: R 2 = R 3*105 R 2 = R 3*15*7 R 2 = R 3*(16 -1)*(8 -1) R 2=(R 3*16) - R 3 puis R 2=(R 2*8)-R 2 rsb R 2, R 3, lsl #4 puis rsb R 2, 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 R 1, R 2 MOV R 1, R 2 LDR R 1, =0 x 00 FFFFFF LDR R 1, =1020 LDR R 1, [R 2] Error OK ldr r 1, [pc, #4] mov r 1, #1020 ldr r 1, [r 2] 28

Instructions (Data Flow) 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 R 0, [R 1] STR R 0, [R 1] On charge dans R 0 le word (32 bits) mem[R 1] On range dans mem[R 1] (4 octets) R 0 L’adresse est placée dans R 1 avec un ADR ou LDR (voir directives) 29

Instructions (Data Flow) Si R 1 « pointe » (ADR R 1, tab) sur une zone mémoire (vecteur, matrice) Rem: une zone mémoire = vecteur, matrice, tableau, … ADD R 1, #2 LDRH R 0, [R 1] R 1 pointe maintenant sur le prochain half-word R 0 reçoit le half-word : R 0=mem 16[R 1] On peut utiliser une pré-indexation (R 1 est modifié avant le transfert): LDRH R 0, [R 1, #2] R 0=mem 16[R 1+2] R 1 mis à jour ? ? ? Quelle syntaxe ? ? ? 30

Instructions (Data Flow) ? ? Rem: [R 1, #4] ne modifie pas R 1 31

Instructions (Data Flow) • Si on veut modifier R 1 « automatiquement » auto-incrémentation LDRH R 0, [R 1, #2]! R 0=mem 16[R 1+2] puis R 1=R 1+2 • Si R 1 pointe toujours sur le prochain élément à charger (pile) post-indexation LDRH R 0, [R 1], #2 R 0=mem 16[R 1] puis R 1=R 1+2 • Si l’offset est variable, un registre peut le remplacer LDRH R 0, [R 1, R 2]! R 0=mem 16[R 1+R 2] puis R 1=R 1+R 2 32

Instructions (Data Flow) Résumé: indirect LDR R 0, [R 1, #offset] indirect pré-indexé LDR R 0, [R 1, #offset]! indirect pré-indexé et auto-incrémenté LDR R 0, [R 1], #offset indirect post-indexé et auto-incrémenté LDR R 0, [R 1, -R 2]! indirect pré-indexé et auto-incrémenté LDR R 0, [R 1], -R 2 indirect post-indexé et auto-incrémenté • LDR R 0, [R 1] • • • 33

Instructions (Data Flow) Encore plus complexe : format Word 34

Instructions (Data Flow) Un LOAD/STORE particulier: SWAP SWP R 1, R 2, [R 3] 1. R 1 mémoire[R 3] 2. mémoire[R 3] R 2 Pour échanger le contenu de la mémoire avec un registre SWP R 2, [R 3] 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 R 2, R 1 LSL #5 , MOV R 3, R 4 LSR R 6 LSL, LSR, ASR, ROR, RRX 36

Instructions Logiques • LSR: logical shift right 0 C • 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 R 1, R 2, R 3 R 1=R 2 -R 3 RSBS R 1, R 2, R 3 R 1=R 3 -R 2 -multiplications 38

Multiplications • MUL rd, r 1, r 2 rd=r 1*r 2 sur 32 bits • MLA rd, r 1, r 2, r 3 rd=r 1*r 2 + r 3 sur 32 bits Signés: • SMULL rdlo, rdhi, r 1, r 2 rd=r 1*r 2 sur 64 bits • SMLAL rdlo, rdhi, r 1, r 2, r 3 rd=r 1*r 2 + r 3 sur 64 bits NON Signés: • UMULL rdlo, rdhi, r 1, r 2 rd=r 1*r 2 sur 64 bits • UMLAL rdlo, rdhi, r 1, r 2, r 3 rd=r 1*r 2 + r 3 sur 64 bits 39

Instructions Arithmétiques Un exemple de MLA: LOOP: MOV LDR MLA SUBS BNE R 11, #20 R 10, #0 R 0, [R 8], #4 R 1, [R 9], #4 R 10, R 1, R 10=R 10+R 0*R 1 R 11, #1 SUB et CMP car {S} LOOP C’est le produit scalaire de deux vecteurs 40

Instructions Arithmétiques Les flags sont mis à jour avec {S} on peut également utiliser CMP (SUBS) ou CMN (ADDS) CMP R 1, #5 R 1 -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

Inst. /struct. de contrôles If Then Else: If R 0 < R 1 Then Else If: CMP R 0, R 1 BHS Else B Endif CMP Rn, <Operand 2 Then: Else: Endif: 43

Inst. /struct. de contrôles Case Of: Case R 2 Of -2: Case: m. Deux: CMP -3: B m. Trois: CMP Otherwise: R 2, #-2 (remplacé par CMN R 1, #2) !! BNE m. Trois Endcase R 2, #-3 BNE Otherwise B Endcase Otherwise: Endcase: 44

Inst. /struct. de contrôles While do: While: While do R 3 R 1 # CMP Rn, <Operand 2> CMP R 3, R 1 BLT Endwhile si Rn LT Operand 2 en signé BLO Endwhile si Rn LO Operand 2 en nonsigné B While do: Endwhile: 45

Inst. /struct. de contrôles For: LDR R 3, =nfin For R 3 = 1 to nfin do For: SUBS R 3, #1 BNE décrémentation de 1 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

Appels de procédures, les Piles proc: . globl _start. globl _main _start: _main: ADD R 3, R 1, R 2 B _main MOV PC, LR MOV R 1, #2 MOV R 2, #3 BL proc branchement à proc et LR (R 14)=PC-4 (Pipeline) STR R 3, res Nombre de registres limité utilisation des piles (C, JAVA) 48

Appels de procédures, les Piles LDR et STR n’utilisent qu’un seul registre LDM et STM utilisent plusieurs registres LDMIA R 1, {R 0, R 2, R 4} (r 0=mem 32[r 1], r 2=mem 32[r 1+4], r 4=mem 32[r 1+8]) R 4 R 3 R 2 R 1 Adresse de base R 0 De même STMIA R 1, {R 0, R 2, R 4} mémoi re (mem 32[r 1]=r 0, mem 32[r 1+4]=r 2, mem 32[r 1+8]=r 4) 49

Appels de procédures, les Piles 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 R 1 !, {R 2 -R 9} alors on charge 8 registres (32 octets) et l’offset est définitif (R 1=R 1+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

Appels de procédures, les Piles R 9’ R 5 R 1 STMIA r 9!, {r 0, r 1, r 5} R 1 STMIB r 9!, {r 0, r 1, r 5} R 9 R 0 STMDB r 9!, {r 0, r 1, r 5} STMDA r 9!, {r 0, r 1, r 5} R 9 R 5 R 9 R 5 R 1 R 0 R 1 R 9’ R 0 R 9’ 51

Appels de procédures, les Piles 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 STMIA STMED (E: emplacement Empty; D: adresses Descending) LDMIB LDMED • Et R 13 (SP) est considéré comme le pointeur de pile 52

Appels de procédures, les Piles 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

Appels de procédures, les Piles 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

Appels de procédures, les Piles. globl _start. globl _main proc: _start: B _main: STMED R 13!, {R 1 -R 2, R 14} LDR R 1, [R 13, #16] MOV R 1, #2 MOV R 2, #3 STMED R 13!, {R 1, R 2} BL proc ADD R 13, #8 (A) (B) (F) (G) LDR R 2, [R 13, #20] ADD R 3, R 1, R 2 STR R 3, res (C) LDMED R 13!, {R 1 -R 2, R 14} (D) MOV PC, R 14 Rem: (C) et (D) peuvent être remplacé par: LDMED R 13!, {R 1 -R 2, PC} R 13 4 octets (C) 4 octets (B), (D) R 1 R 2 R 14 (A), (G) R 1 AD+ R 2 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: R 10 : SL (stack limit) R 11 : FP (frame pointer) R 12 : IP (scratch register) R 13 : SP (stack pointer) R 14 : LR (link register) R 15 : PC Et R 0 -R 3 : A 1 -A 4 arguments de proc/registres de travails/résultats R 4 -R 9 : V 1 -V 6 variable registre 57

Appels de procédures, APCS La pile (et les différents registres) permet de conserver une structure d’appel pour les appels imbriqués: Sauvegarde PC LR LR SP SP FP FP … … Contexte p 4 Contexte p 3 Contexte p 2 Contexte p 1 58

Appels de procédures, APCS Exemple int somme(int x 1, int x 2, int x 3, int x 4, int x 5) { return x 1+x 2+x 3+x 4+x 5; } //extern int somme(int x 1, int x 2, int x 3, int x 4, int x 5); int __main() { somme(2, 3, 4, 5, 6); } . global __main: __main mov stmfd sub mov str mov mov bl ldmea ip, sp sp!, {fp, ip, lr, pc} fp, ip, #4 sp, #4 r 3, #6 r 3, [sp, #0] r 0, #2 r 1, #3 r 2, #4 r 3, #5 somme fp, {fp, sp, pc} somme: . text. global. type mov stmfd sub str str ldr add ldr add mov ldmea somme, function ip, sp sp!, {fp, ip, lr, pc} fp, ip, #4 sp, #16 r 0, [fp, #-16] r 1, [fp, #-20] r 2, [fp, #-24] r 3, [fp, #-28] r 2, [fp, #-16] r 3, [fp, #-20] r 3, r 2, r 3 r 2, [fp, #-24] r 3, r 2, [fp, #-28] r 3, r 2, [fp, #4] r 3, r 2 r 0, r 3 fp, {fp, sp, pc} 59

Appels de procédures, APCS Restauration des registres somme: SP(1) mov stmfd (STMDB) sub ip, sp sp!, {fp, ip, lr, pc} SP(2) fp, ip, #4 FP(1) ldmea (LDMDB) fp, {fp, sp, pc} SP(1) . . . FP(1) SP(2) 4 octets FP FP(1) IP (sp(1)) LR SP(1) AD+ PC 60

Appels de procédures, APCS somme: SP(3) __main: SP(1) . text. global. type mov stmfd sub str somme, function ip, sp sp!, {fp, ip, lr, pc} SP(4) fp, ip, #4 FP(2) sp, #16 SP(5) r 0, [fp, #-16] mov stmfd sub mov str ip, sp sp!, {fp, ip, lr, pc} SP(2) fp, ip, #4 FP(1) sp, #4 SP(3) r 3, #6 r 3, [sp, #0] SP(5) R 3 so str str ldr add ldr r 1, [fp, #-20] r 2, [fp, #-24] r 3, [fp, #-28] r 2, [fp, #-16] r 3, [fp, #-20] r 3, r 2, r 3 r 2, [fp, #-24] mov mov bl ldmea r 0, #2 r 1, #3 r 2, #4 r 3, #5 somme fp, {fp, sp, pc} SP(1) SP(4) R 2 so R 1 so R 0 so FPso IPso LRso add ldr add mov ldmea FP(2) SP(3) SP(2) PCso R 3 ma Fpma r 3, r 2, [fp, #-28] r 3, r 2, [fp, #4] r 3, r 2 r 0, r 3 fp, {fp, sp, pc} SP(3) FP(1) IPma LRma SP(1) PCma 61

Appels de procédures, APCS somme: SP(3) __main: SP(1) . text. global. type mov stmfd sub str mov stmfd sub sub str somme, function ip, sp sp!, {fp, ip, lr, pc} SP(4) fp, ip, #4 FP(2) sp, #16 SP(5) r 0, [fp, #-16] ip, sp sp!, {fp, ip, lr, pc} SP(2) fp, ip, #4 FP(1) sp, #4 SP(3) r 3, fp, #16 r 3, [sp, #0] str str ldr add ldr r 1, [fp, #-20] r 2, [fp, #-24] r 3, [fp, #-28] r 2, [fp, #-16] r 3, [fp, #-20] r 2, r 3, [fp, #-24] mov mov bl ldmea r 0, #2 r 1, #3 r 2, #4 r 3, #5 somme fp, {fp, sp, pc} SP(1) add ldr str ldmea Dans ce cas, on passe l’adresse du résultat !!! (5 arguments) void somme(int x 1, int x 2, int x 3, int x 4, int *x) { *x= x 1+x 2+x 3+x 4; } int __main() { int c; somme(2, 3, 4, 5, &c); } r 2, r 3, [fp, #-28] r 2, r 3, [fp, #4] r 2, [r 3, #0] fp, {fp, sp, pc} SP(3) 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

Procédures particulières De nouveaux registres 64

Procédures particulières Quand une exception est levée: • Le mode système est modifié (fonction du type) • PC est sauvegardé dans le R 14 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 0 x 0000, …) 65