La présentation est en train de télécharger. S'il vous plaît, attendez

La présentation est en train de télécharger. S'il vous plaît, attendez

ARM-meste-20051 ASSEMBLEUR (ARM). ARM-meste-20052 Pourquoi-Comment ? Objectifs –Comprendre que lassembleur est le meilleur ami de larchitecture –Les assembleurs.

Présentations similaires


Présentation au sujet: "ARM-meste-20051 ASSEMBLEUR (ARM). ARM-meste-20052 Pourquoi-Comment ? Objectifs –Comprendre que lassembleur est le meilleur ami de larchitecture –Les assembleurs."— Transcription de la présentation:

1 ARM-meste ASSEMBLEUR (ARM)

2 ARM-meste Pourquoi-Comment ? Objectifs –Comprendre que lassembleur est le meilleur ami de larchitecture –Les assembleurs peuvent être très différents –Ne pas vous spécialiser dans un assembleur spécifique –Dépasser le 68000/8086 (www.essi.fr/~meste/ESSI1/ASSEMBLEUR.doc)

3 ARM-meste Pourquoi-Comment ? Comment: –En se basant sur Processi –En étudiant un Processeur Simple (RISC) ARM (7) –Hélas pas si simple –Sans manipuler un vrai processeur Cross-compilateur + simulateur

4 ARM-meste Introduction (1) Le cours darchitecture a illustré la conception dun microprocesseur avec pour outil de modélisation les FSM le mot placé dans IR (mot instruction) contient toute linformation 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 dun mnémonique + opérandes réduisant leffort de codage (ex : movnes R0,R1,ROR R2 ) le mnémonique + op nest quune représentation différente de la même information le microprocesseur nutilise que la première représentation, cest lopération dassemblage qui traduit (cest un compilateur qui génère un code du premier type) le code assembleur en code machine

5 ARM-meste Introduction (2) Lensemble (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)

6 ARM-meste 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, …

7 ARM-meste Que manipule-t-on ? Des registres Des adresses Des données Des instructions assembleurs (32 bits) Des directives Des pseudo-instructions

8 ARM-meste Des registres (mode User) 16 Registres de 32 bits R0-R10, R12 : généraux R11 (fp) Frame pointer R13 (sp) Stack pointer R14 (lr) Link register R15 (pc) Program counter Current Program Status Register R0 R1 R2 R3 R4 R5 R6 R7 R8 R9 R10 R11 R12 R13 R14 R N Z C VPas utilisés IFTMode

9 ARM-meste Des adresses et données 2 32 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 (0b )

10 ARM-meste Organisation mémoire bit31bit word Half-word14Half-word word Byte6Half-word byte3byte2byte1byte0 adresse

11 ARM-meste Chaque instruction est codée sur 32 bits (uniquement) !!! Comme Processi ?

12 ARM-meste Cond (toutes les instructions !)

13 ARM-meste OpCode (data processing)

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

15 ARM-meste Environnement de Prog. En « cross-compilant » (outil GNU) En « linkant » (outil GNU) En simulant le processeur ARM EmBest Ide

16 ARM-meste

17 ARM-meste Les directives principales Les directives sont des intructions pour lassembleur (compilateur) uniquement, elles commencent par «. »..align: permet daligner en mémoire des données de types différents.byte0x55.alignsinon erreur à lassemblage.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

18 ARM-meste Les directives principales.byte: déclare une variable type octet et initialisation var1:.byte0x11 var2:.byte0x22,0x33.hword: déclare une variable type deux octets et initialisation var3:.hword0x1122 var4:.hword0x44.word: déclare une variable type word (32bits) et initialisation var5:.word0x space: déclare une variable de taille quelconque (pas d initialisation) var6:.space10réserve 10 octets

19 ARM-meste Les directives principales.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,=0x ltorg

20 ARM-meste 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 ldrR0,=42 mov R0, #42 ldrR1,=0x9988CDEF ldr R1,[PC, #4] (pipeline !!!) nop.ltorgcest ici que lon trouve #0x9988CDEF

21 ARM-meste Pseudo-instructions ldrR3,var3 ldr R3,[PC, #0] charge dans R3 la valeur de var3 ldrR4,=var3 ldr R4,[PC, #0] écrit en mémoire ladresse de var3 charge ladresse de var3 var3:.word0xAAAAAAAA.ltorgon trouve ici ladresse de var3 REM: ladresse de var3 est connue par lassembleur, on peut mieux faire

22 ARM-meste Pseudo-instructions ADR : charge dans un registre ladresse dune variable (load/store) adrR4, var5 add R4,PC,#4 (des fois sub !!!) ldrR6,[R4] nop var5:.word 0xBBBBBBBB PAS de.ltorg car ladresse nest pas en mémoire REM: les valeurs immédiates sont limitées en taille, si les variables sont dans.data adrl ou ldr =

23 ARM-meste Pseudo-instructions LDR le Retour main: ldr R3,=0x1111 ldr R4,=0x1000 var7:.word 0x11 Après désassemblage: main : 0x ldr r3, [pc, #4]; 0x x mov r4, #4096 bizarre var7 : 0x candeq r0, r0, r1, lsl r0 0x andeq r1, r0, r1, lsl r1 On utilise ltorg On nutilise pas ltorg

24 ARM-meste Module de décalage Cela sexplique grâce au registre à décalage -Le registre à décalage peut réaliser des rotations à droite également -Ne rajoute pas de cycle horloge -Ne sutilise pas en tant quinstruction -Permet de charger des constantes >8b -Permet des MUL rapides Cest lALU Reg à décalage Opérande 1Opérande 2

25 ARM-meste 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 Cest à dire: [0-0xFF] sur 8 bits et 0 rotation Mais encore: 256, 260, …, 1020 [0x100-0x3FC]=[0x40-0xFF] ROR #30 0x3FC: 0xFF: 0xFF ror #1 ……. 0xFF ror #

26 ARM-meste Module de décalage Et ainsi: 1024, 1040, …, 4080 [0x400-0xFF0]=[0x40-0xFF] ROR # , 4160, …, [0x1000-0x3FC0]=[0x40-0xFF] ROR #26 Ex: movR1, #0x1000 mov R1,#40,26 (pas une vraie syntaxe) movR2, #0xFFFFFFFF mvn R2,#0 movR2, #0x génère une erreur !!! ldrR2, # 0x on a déjà vu, pas derreur De plus LDR gère le registre à décalage on utilise si possible LDR pour charger des constantes

27 ARM-meste 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 Nest pas remplacé par lAssembleur !!!

28 ARM-meste Instructions On les rassemble en 3 groupes: Mouvements de données Opérations de traitements (arith. & log.) Instructions de contrôles

29 ARM-meste 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

30 ARM-meste 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]

31 ARM-meste 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 R0,[R1] On charge dans R0 le word (32bits) mem[R1] STR R0,[R1] On range dans mem[R1] (4 octets) R0 Ladresse est placée dans R1 avec un ADR ou LDR (voir directives)

32 ARM-meste Instructions (Data Flow) 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=mem 16 [R1] On peut utiliser une pré-indexation (R1 est modifié avant le transfert): LDRH R0, [R1,#2] R0=mem 16 [R1+2] R1 mis à jour ??? Quelle syntaxe ???

33 ARM-meste Instructions (Data Flow) ? ? Rem: [R1,#4] ne modifie pas R1

34 ARM-meste Instructions (Data Flow) Si on veut modifier R1 « automatiquement » auto-incrémentation LDRH R0, [R1,#2]! R0=mem 16 [R1+2] puis R1=R1+2 Si R1 pointe toujours sur le prochain élément à charger (pile) post-indexation LDRH R0,[R1],#2 R0=mem 16 [R1] puis R1=R1+2 Si loffset est variable, un registre peut le remplacer LDRH R0,[R1,R2]! R0=mem 16 [R1+R2] puis R1=R1+R2

35 ARM-meste Instructions (Data Flow) 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é

36 ARM-meste Instructions (Data Flow) Encore plus complexe : format Word

37 ARM-meste Instructions (Data Flow) Un LOAD/STORE particulier: SWAP SWP R1,R2,[R3] 1.temp=mem[R3] 2.mem[R3]=R2 3.R1=temp Pour échanger le contenu de la memoire avec un registre SWP R2, R2, [R3]

38 ARM-meste 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

39 ARM-meste Instructions Logiques LSR: logical shift right ASR: arithmetic shift right ROR: rotate right RRX: rotate right extended Un seul bit remplacé par ROR #0 C C 0 C C

40 ARM-meste Instructions Arithmétiques Elles permettent laddition, 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,E2,R3 R1=R3-R2 -MUL, MLA: multiplication résultat 32 bits, avec accumulation (dés fois) LSL, ADD, SUB

41 ARM-meste Instructions Arithmétiques Un exemple de MLA: MOVR11, #20 MOVR10, #0 LOOP:LDRR0,[R8], #4 LDRR1,[R9], #4 MLAR10,R0,R1,R10 R10=R10+R0*R1 SUBSR11,R11,#1 SUB et CMP car {S} BNELOOP Cest le produit scalaire de deux vecteurs

42 ARM-meste Instructions Arithmétiques 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

43 ARM-meste 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

44 ARM-meste If:CMP R0,R1 CMP Rn, BLO Then si Rn LO Operand2 alors BElse Then: BEndif Else: Endif: Inst./struct. de contrôles If Then Else: If R0 < R1 Then Else

45 ARM-meste Inst./struct. de contrôles Case Of: Case R2 Of -2: -3: Otherwise: Case: mDeux: CMP R2,#-2 (remplacé par CMN R1,#2) !! BNE mTrois BEndcase mTrois:CMP R2,#-3 BNE Otherwise B Endcase Otherwise: Endcase:

46 ARM-meste Inst./struct. de contrôles While do: While R3 R1 do While:CMP R3,R1 CMP Rn, BGE do si Rn GE Operand2 en signé #BHS do si Rn HS Operand2 en nonsigné BEndwhile do: BWhile Endwhile:

47 ARM-meste Inst./struct. de contrôles For: For R3 = 1 to 10do LDR R3,=1 For:CMP R3,#10 CMP Rn, BLS do si Rn Operand2 en non signé BEndfor do: ADD R3,R3,#1 incrémentation de 1 BFor Endfor:

48 ARM-meste 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

49 ARM-meste Appels de procédures, les Piles.globl _start.globl _main _start: B _main _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) proc: ADD R3,R1,R2 MOV PC,LR

50 ARM-meste Appels de procédures, les Piles LDR et STR nutilisent quun seul registre LDM et STM utilisent plusieurs registres LDMIA R1,{R0,R2,R4}(r0=mem 32 [r1], r2=mem 32 [r1+4], r4=mem 32 [r1+8]) De même STMIA R1,{R0,R2,R4} (mem 32 [r1]=r0, mem 32 [r1+4]=r2, mem 32 [r1+8]=r4) R4 R3 R2 R1Adresse de base R0 mémoire

51 ARM-meste Appels de procédures, les Piles Linstruction LDMIA est en fait LDM + I + A LDM : Load Multiple I : Incrémentation de ladresse de base A: ladresse de base est incrémentée après utilisation (offset temporaire) Si LDMIA R1 !, {R2-R9} alors on charge 8 registres (32 octets) et loffset est définitif (R1=R1+32) après utilisation Le I+A peut se remplacer par: Increment-AfterLDMIASTMIA Increment-BeforeLDMIBSTMIB Decrement-AfterLDMDASTMDA Decrement-BeforeLDMDBSTMDB

52 ARM-meste Appels de procédures, les Piles R9 R5 STMIA r9!,{r0,r1,r5}R1 R9 R0 R9 R5 R1 STMIB r9!,{r0,r1,r5}R0 R9 STMDA r9!,{r0,r1,r5} R9 R5 R1 R0 R9 STMDB r9!,{r0,r1,r5} R9 R5 R1 R9 R0

53 ARM-meste Appels de procédures, les Piles Ces instructions permettent limplémentation de Piles (PUSH et POP) : PUSH : STMIA POP: LDMIB 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

54 ARM-meste 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

55 ARM-meste 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

56 ARM-meste Appels de procédures, les Piles.globl _start.globl _main _start: B _main _main: MOV R1,#2 MOV R2,#3 (A)STMED R13!,{R1,R2} (B)BL proc (F)ADD R13,R13,#8 (G)STR R3,res proc: STMED R13!,{R1-R2,R14} LDR R1,[R13,#16] LDR R2,[R13,#20] ADD R3,R1,R2 (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 R1R2R14R1R2

57 ARM-meste Appels de procédures,APCS (réduit) Le APCS (ARM Procedure Call Standard) fournit un mécanisme standardisé permettant dassocier des routines C, assembleur, … En définissant: Restrictions sur lutilisation des registres Convention dutilisation 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 ???

58 ARM-meste 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 Comment faire si plus de 4 arguments ???

59 ARM-meste Appels de procédures, APCS La pile (et les différents registres) permet de conserver une structure dappel pour les appels imbriqués: Sauvegarde PC LR SP FP … Contexte p4 Sauvegarde PC LR SP FP … Contexte p3 Sauvegarde PC LR SP FP … Contexte p2 Sauvegarde PC LR SP FP … Contexte p1

60 ARM-meste Appels de procédures, APCS Exemple int somme(int x1, int x2, int x3, int x4, int x5) { return x1+x2+x3+x4+x5; } //extern int somme(int x1, int x2, int x3, int x4, int x5); int __main() { somme(2,3,4,5,6); }.text.globalsomme.typesomme,function somme:movip, sp stmfdsp!, {fp, ip, lr, pc} subfp, ip, #4 subsp, sp, #16 strr0, [fp, #-16] strr1, [fp, #-20] strr2, [fp, #-24] strr3, [fp, #-28] ldrr2, [fp, #-16] ldrr3, [fp, #-20] addr3, r2, r3 ldrr2, [fp, #-24] addr3, r3, r2 ldrr2, [fp, #-28] addr3, r3, r2 ldrr2, [fp, #4] addr3, r3, r2 movr0, r3 ldmeafp, {fp, sp, pc}.global__main __main:movip, sp stmfdsp!, {fp, ip, lr, pc} subfp, ip, #4 subsp, sp, #4 movr3, #6 strr3, [sp, #0] movr0, #2 movr1, #3 movr2, #4 movr3, #5 blsomme ldmeafp, {fp, sp, pc}

61 ARM-meste Appels de procédures, APCS Restauration des registres bizarre ??? somme:movip, sp SP(1) stmfdsp!, {fp, ip, lr, pc} SP(2) (STMDB) subfp, ip, #4 FP(1). FP(1) ldmeafp, {fp, sp, pc}SP(1) (LDMDB) SP(2)FP(1)SP(1)AD+ 4 octets FPIP (sp(1)) LRPC

62 ARM-meste Appels de procédures, APCS.text.globalsomme.typesomme,function somme:movip, sp SP(3) stmfdsp!, {fp, ip, lr, pc} SP(4) subfp, ip, #4 FP(2) subsp, sp, #16 SP(5) strr0, [fp, #-16] strr1, [fp, #-20] strr2, [fp, #-24] strr3, [fp, #-28] ldrr2, [fp, #-16] ldrr3, [fp, #-20] addr3, r2, r3 ldrr2, [fp, #-24] addr3, r3, r2 ldrr2, [fp, #-28] addr3, r3, r2 ldrr2, [fp, #4] addr3, r3, r2 movr0, r3 ldmeafp, {fp, sp, pc} SP(3) __main:movip, sp SP(1) stmfdsp!, {fp, ip, lr, pc} SP(2) subfp, ip, #4 FP(1) subsp, sp, #4 SP(3) movr3, #6 strr3, [sp, #0] movr0, #2 movr1, #3 movr2, #4 movr3, #5 blsomme ldmeafp, {fp, sp, pc} SP(1) SP(5)SP(4)FP(2)SP(3)SP(2)FP(1)SP(1) R3soR2soR1soR0soFPsoIPsoLRsoPCsoR3maFpmaIPmaLRmaPCma

63 ARM-meste Appels de procédures, APCS Dans ce cas, on passe ladresse 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); }.text.globalsomme.typesomme,function somme:movip, sp SP(3) stmfdsp!, {fp, ip, lr, pc} SP(4) subfp, ip, #4 FP(2) subsp, sp, #16 SP(5) strr0, [fp, #-16] strr1, [fp, #-20] strr2, [fp, #-24] strr3, [fp, #-28] ldrr2, [fp, #-16] ldrr3, [fp, #-20] addr2, r2, r3 ldrr3, [fp, #-24] addr2, r2, r3 ldrr3, [fp, #-28] addr2, r2, r3 ldrr3, [fp, #4] strr2, [r3, #0] ldmeafp, {fp, sp, pc} SP(3) __main:movip, sp SP(1) stmfdsp!, {fp, ip, lr, pc} SP(2) subfp, ip, #4 FP(1) subsp, sp, #4 SP(3) subr3, fp, #16 strr3, [sp, #0] movr0, #2 movr1, #3 movr2, #4 movr3, #5 blsomme ldmeafp, {fp, sp, pc} SP(1)

64 ARM-meste 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 dune instruction (SWI, instruction illégale, erreur mémoire en FETCH) Par un effet de bord dune instruction (erreur mémoire data, division par zéro) En réponse à un signal extérieure (reset, Fast Interrupt FIQ, Normal interrupt)

65 ARM-meste Procédures particulières De nouveaux registres

66 ARM-meste Procédures particulières 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 à ladresse de lexception correspondante (Branch) Cette adresse est stockée dans un tableau dadresses (vecteurs) Le microprocesseur « détermine » quel vecteur pour quelle exception (reset: premier vecteur du tableau donc 0x , …)


Télécharger ppt "ARM-meste-20051 ASSEMBLEUR (ARM). ARM-meste-20052 Pourquoi-Comment ? Objectifs –Comprendre que lassembleur est le meilleur ami de larchitecture –Les assembleurs."

Présentations similaires


Annonces Google