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

ARM-meste-2005 1

ASSEMBLEUR (ARM)

ARM-meste-2005 2

Pourquoi-Comment ?

• Objectifs– Comprendre que l’assembleur est le meilleur

ami de l’architecture– 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)

ARM-meste-2005 3

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

ARM-meste-2005 4

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

ARM-meste-2005 5

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)

ARM-meste-2005 6

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, …

ARM-meste-2005 7

Que manipule-t-on ?

• Des registres

• Des adresses

• Des données

• Des instructions assembleurs (32 bits)

• Des directives

• Des pseudo-instructions

ARM-meste-2005 8

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 28 27 8

7 6 5 4 0

N Z C V Pas utilisés IF T Mode

ARM-meste-2005 9

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)

ARM-meste-2005 10

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 byte0adresse

ARM-meste-2005 11

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

Comme Processi ?

ARM-meste-2005 12

Cond (toutes les instructions !)

ARM-meste-2005 13

OpCode (data processing)

ARM-meste-2005 14

Environnement de Prog..text directive.globl _main

_start: labelb _main

_main: code op opmrs R0,CPSR opérandes

#attention à la taille des immédiats !!ldr R1,=0xDFFFFFFFand R0,R0,R1msr CPSR_f,R0

#autre solution:pas de masquage, on force tous les bits# msr CPSR_f,#0xD

ldrb R0,mysldrb R1,readds R0,R0,R1strb R0,de

ldrb R0,teldrb R1,bouladc R0,R0,R1strb R0,gom

mov pc,lr

.alignmys: .space 1te: .space 1re: .space 1boul: .space 1de: .space 1gom: .space 1

.ltorg

.end

ARM-meste-2005 15

Environnement de Prog.

• En « cross-compilant » (outil GNU)

• En « linkant » (outil GNU)

• En simulant le processeur ARM• EmBest Ide

ARM-meste-2005 16

ARM-meste-2005 17

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

ARM-meste-2005 18


• .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

ARM-meste-2005 19


• .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

ARM-meste-2005 20

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

ARM-meste-2005 21

Pseudo-instructions

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

charge dans R3 la valeur de var3

ldr R4,=var3 ldr 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

ARM-meste-2005 22

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 =

ARM-meste-2005 23

Pseudo-instructions LDR le Retour

main:

ldr R3,=0x1111

ldr R4,=0x1000

var7: .word 0x11

Après désassemblage:

main :

0x02000004 ldr r3, [pc, #4]; 0x2000010

0x02000008 mov r4, #4096 bizarre

var7 :

0x0200000c andeq r0, r0, r1, lsl r0

0x02000010 andeq r1, r0, r1, lsl r1

On utilise ltorg

On n’utilise pas ltorg

ARM-meste-2005 24

Module de décalage

Cela s’explique grâce au 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 >8b

-Permet des MUL rapides

C’est l’ALU

Reg à décalage

Opérande 1 Opérande 2

ARM-meste-2005 25

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:

0xFF ror #1

……. 0xFF ror #30

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

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

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

ARM-meste-2005 26

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

ARM-meste-2005 27

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 !!!

ARM-meste-2005 28

Instructions

On les rassemble en 3 groupes:

• Mouvements de données

• Opérations de traitements (arith. & log.)

• Instructions de contrôles

ARM-meste-2005 29

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

ARM-meste-2005 30

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]

ARM-meste-2005 31


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)

ARM-meste-2005 32


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 ???

ARM-meste-2005 33


?

?

Rem: [R1,#4]

ne modifie pas R1

ARM-meste-2005 34


• 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

ARM-meste-2005 35


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é

ARM-meste-2005 36


Encore plus complexe : format Word

ARM-meste-2005 37


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]

ARM-meste-2005 38

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

ARM-meste-2005 39

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

C0

C

C

ARM-meste-2005 40

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,E2,R3 R1=R3-R2

-MUL, MLA: multiplication résultat 32 bits, avec accumulation

(dés fois) LSL, ADD, SUB

ARM-meste-2005 41


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

ARM-meste-2005 42


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

ARM-meste-2005 43

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

ARM-meste-2005 44

If: CMP R0,R1 CMP Rn,<Operand2>

BLO Then si Rn LO Operand2 alors

B Else

Then:

B Endif

Else:

Endif:


If Then Else:

If R0 < R1

Then

Else

ARM-meste-2005 45


Case Of:

Case R2 Of

-2:

-3:

Otherwise:

Case:

mDeux: CMP R2,#-2 (remplacé par CMN R1,#2) !!BNE mTrois

B Endcase

mTrois: CMP R2,#-3

BNE Otherwise

B Endcase

Otherwise:

Endcase:

ARM-meste-2005 46


While do:

While R3 R1

do

While: CMP R3,R1 CMP Rn,<Operand2>

BGE do si Rn GE Operand2 en signé

# BHS do si Rn HS Operand2 en nonsigné

B Endwhile

do:

B While

Endwhile:

ARM-meste-2005 47


For:

For R3 = 1 to 10 do

LDR R3,=1

For: CMP R3,#10 CMP Rn,<Operand2>

BLS do si Rn Operand2 en non signé

B Endfor

do:

ADD R3,R3,#1 incrémentation de 1

B For

Endfor:

ARM-meste-2005 48

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

ARM-meste-2005 49


.globl _start

.globl _main

_start: B _main_main:

MOV R1,#2MOV R2,#3BL 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

ARM-meste-2005 50


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])

De même

STMIA R1,{R0,R2,R4} (mem32[r1]=r0, mem32[r1+4]=r2, mem32[r1+8]=r4)

R4

R3

R2

R1 Adresse de base

R0 mémoire

ARM-meste-2005 51


L’instruction LDMIA est en fait LDM + I + ALDM : Load MultipleI : Incrémentation de l’adresse de baseA: 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 STMIAIncrement-Before LDMIB STMIBDecrement-After LDMDA STMDADecrement-Before LDMDB STMDB

ARM-meste-2005 52

Appels de procédures, les PilesR9’

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

ARM-meste-2005 53


Ces instructions permettent l’implémentation de Piles (PUSH et POP) : • PUSH : STMIA• POP : LDMIBLe 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 STMSTMIA STMED (E: emplacement Empty; D: adresses Descending)LDMIB LDMED

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

ARM-meste-2005 54


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éduresavec normalisation (ARM Procedure Call Standard) ou non

ARM-meste-2005 55


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

ARM-meste-2005 56


.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 4 octets 4 octets 4 octets R1 R2 R14 R1 R2

ARM-meste-2005 57

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 ???

ARM-meste-2005 58

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ésultatsR4-R9 : V1-V6 variable registre

Comment faire si plus de 4 arguments ???

ARM-meste-2005 59


La pile (et les différents registres) permet de conserver une structure d’appel 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

ARM-meste-2005 60


Exempleint 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

.global somme

.type somme,functionsomme: mov ip, sp

stmfd sp!, {fp, ip, lr, pc}sub fp, ip, #4sub sp, sp, #16str r0, [fp, #-16]str r1, [fp, #-20]str r2, [fp, #-24]str r3, [fp, #-28]ldr r2, [fp, #-16]ldr r3, [fp, #-20]add r3, r2, r3ldr r2, [fp, #-24]add r3, r3, r2ldr r2, [fp, #-28]add r3, r3, r2ldr r2, [fp, #4]add r3, r3, r2mov r0, r3ldmea fp, {fp, sp, pc}

.global __main__main: mov ip, sp

stmfd sp!, {fp, ip, lr, pc}sub fp, ip, #4sub sp, sp, #4mov r3, #6str r3, [sp, #0]mov r0, #2mov r1, #3mov r2, #4mov r3, #5bl sommeldmea fp, {fp, sp, pc}

ARM-meste-2005 61


Restauration des registres bizarre ???

somme: mov ip, spSP(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

ARM-meste-2005 62


.text

.global somme

.type somme,functionsomme: mov ip, spSP(3) stmfd sp!, {fp, ip, lr, pc} SP(4)

sub fp, ip, #4 FP(2)

sub sp, sp, #16 SP(5)

str r0, [fp, #-16]

str r1, [fp, #-20]str r2, [fp, #-24]str r3, [fp, #-28]ldr r2, [fp, #-16]ldr r3, [fp, #-20]add r3, r2, r3ldr r2, [fp, #-24]

add r3, r3, r2ldr r2, [fp, #-28]add r3, r3, r2ldr r2, [fp, #4]add r3, r3, r2mov r0, r3ldmea fp, {fp, sp, pc} SP(3)

__main: mov ip, spSP(1) stmfd sp!, {fp, ip, lr, pc} SP(2)



mov r3, #6str r3, [sp, #0]

mov r0, #2mov r1, #3mov r2, #4mov r3, #5bl sommeldmea 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

ARM-meste-2005 63


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); }

.text

.global somme

.type somme,functionsomme: mov ip, spSP(3) stmfd sp!, {fp, ip, lr, pc} SP(4)



str r0, [fp, #-16]

str r1, [fp, #-20]str r2, [fp, #-24]str r3, [fp, #-28]ldr r2, [fp, #-16]ldr r3, [fp, #-20]add r2, r2, r3ldr r3, [fp, #-24]

add r2, r2, r3ldr r3, [fp, #-28]add r2, r2, r3ldr r3, [fp, #4]str r2, [r3, #0]ldmea fp, {fp, sp, pc} SP(3)

__main: mov ip, spSP(1) stmfd sp!, {fp, ip, lr, pc} SP(2)



sub r3, fp, #16str r3, [sp, #0]

mov r0, #2mov r1, #3mov r2, #4mov r3, #5bl sommeldmea fp, {fp, sp, pc} SP(1)

ARM-meste-2005 64

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)

ARM-meste-2005 65

Procédures particulièresDe nouveaux registres

ARM-meste-2005 66

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 à 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, …)

Documents

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