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-20051 ASSEMBLEUR (ARM)

2 ARM-meste-20052 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-20053 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-20054 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-20055 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-20056 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-20057 Que manipule-t-on ? Des registres Des adresses Des données Des instructions assembleurs (32 bits) Des directives Des pseudo-instructions

8 ARM-meste-20058 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 R15 31 2827 87 654 0 N Z C VPas utilisés IFTMode

9 ARM-meste-20059 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 (0b00001111)

10 ARM-meste-200510 Organisation mémoire bit31bit0 23222120 19181716 word16 15141312 Half-word14Half-word12 111098 word8 7654 Byte6Half-word14 3210 byte3byte2byte1byte0 adresse

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

12 ARM-meste-200512 Cond (toutes les instructions !)

13 ARM-meste-200513 OpCode (data processing)

14 ARM-meste-200514 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-200515 Environnement de Prog. En « cross-compilant » (outil GNU) En « linkant » (outil GNU) En simulant le processeur ARM EmBest Ide

16 ARM-meste-200516

17 ARM-meste-200517 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-200518 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:.word0x11223344.space: déclare une variable de taille quelconque (pas d initialisation) var6:.space10réserve 10 octets

19 ARM-meste-200519 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,=0x11111111.ltorg

20 ARM-meste-200520 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-200521 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-200522 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-200523 Pseudo-instructions LDR le Retour main: ldr R3,=0x1111 ldr R4,=0x1000 var7:.word 0x11 Après désassemblage: main : 0x02000004ldr r3, [pc, #4]; 0x2000010 0x02000008mov r4, #4096 bizarre var7 : 0x0200000candeq r0, r0, r1, lsl r0 0x02000010andeq r1, r0, r1, lsl r1 On utilise ltorg On nutilise pas ltorg

24 ARM-meste-200524 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-200525 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-255 [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 #30 00000000000000000000001111111100 00000000000000000000000011111111 10000000000000000000000001111111 00000000000000000000001111111100

26 ARM-meste-200526 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: movR1, #0x1000 mov R1,#40,26 (pas une vraie syntaxe) movR2, #0xFFFFFFFF mvn R2,#0 movR2, #0x11111111 génère une erreur !!! ldrR2, # 0x11111111 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-200527 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-200528 Instructions On les rassemble en 3 groupes: Mouvements de données Opérations de traitements (arith. & log.) Instructions de contrôles

29 ARM-meste-200529 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-200530 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-200531 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-200532 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-200533 Instructions (Data Flow) ? ? Rem: [R1,#4] ne modifie pas R1

34 ARM-meste-200534 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-200535 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-200536 Instructions (Data Flow) Encore plus complexe : format Word

37 ARM-meste-200537 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-200538 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-200539 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-200540 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-200541 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-200542 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-200543 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-200544 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-200545 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-200546 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-200547 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-200548 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-200549 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-200550 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-200551 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-200552 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-200553 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-200554 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-200555 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-200556 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-200557 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-200558 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-200559 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-200560 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-200561 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-200562 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-200563 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-200564 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-200565 Procédures particulières De nouveaux registres

66 ARM-meste-200566 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 0x00000000, …)


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