Mode d'adressage
description
Transcript of Mode d'adressage
Mode d'adressageMode d'adressage
merci Laurent JEANPIERRE
Contenu du coursContenu du cours
DéfinitionDéfinition
Adressage simple
Note sur le stockage en mémoire
Adressage complexe
Note sur les segments
DéfinitionDéfinition
Les opérandes d’une instruction peuvent être exprimées de plusieurs façons :Directe (valeur immédiate)Indirecte (valeur dans une case mémoire)Registre (valeur dans un registre)Basée (valeur indirecte via registre)Indexée (Basée + Registre {+ Echelle})Basée/Indexée + décalage
C’est ce que l’on nomme desModes d’adressages
Contenu du coursContenu du cours
Définition
Adressage simpleAdressage simple
Note sur le stockage en mémoire
Adressage complexe
Note sur les segments
Modes d’adressage simplesModes d’adressage simples
Opérande Registre
Valeur contenue dans un registre
v = Registre
Exemples :
# al contient -1 = 255 = 111111112
movb %al, %bl \ # bl = 255=-1, ebx=0x??????FF
movsbl %al, %ebx \ # bl=255=-1, ebx=0xFFFFFFFF=-1
movzbl %al, %ebx \ # bl=255=-1, ebx=0x000000FF=255
Modes d’adressage simplesModes d’adressage simples
Valeur immédiateValeur fixe stockée dans le code opératoireEx : movl $1,%eax # eax 1
Valeur indirecteValeur stockée dans une case mémoire fixe
v = Mem(adresse)Exemples :
movl (1),%eax # eax Mem(DS:1..4)movw prix,%bx # bx Mem(DS:prix..prix+1)
UtilisationUtilisation
Valeur immédiate
Insertion de valeur dans un programme
Valeur indirecte
Accès à une variable globale
Accès à une constante
Registre
Variable intermédiaire
Stockage temporaire
Résultat de fonction (EAX)
Gestion de la pile (EBP/ESP)
Contenu du coursContenu du cours
Définition
Adressage simple
Note sur le stockage en mémoireNote sur le stockage en mémoire
Adressage complexe
Note sur les segments
Note sur le stockage en mémoireNote sur le stockage en mémoire
Les processeurs x86 sont Little-Endian
Le poids faible est stocké en premier
Danger ! (contre la nature humaine)
Exemple:
movl $0x04030201,(v)
movw (v),%ax
AX = 0x0201
Car en mémoire :
v: 01 02 03 04
Note sur le stockage en mémoireNote sur le stockage en mémoire
On aligne ses données
On aligne ses instructions
Contenu du coursContenu du cours
Définition
Adressage simple
Note sur le stockage en mémoire
Adressage complexeAdressage complexe
Note sur les segments
Modes d’adressage complexes (1)Modes d’adressage complexes (1)
Adressage basé :
Valeur contenue en mémoire à l’adresse contenue dans un registre :
v = Mem(Registre)
Exemple :
movl %eax,(%esp) # Mem[SS:esp..esp+3]eax
Registres utilisables :
eax,ebx,ecx,edx (segment DS)
esp,ebp (segment SS)
esi,edi (segment DS)
Adressage Basé : utilisationsAdressage Basé : utilisations
Notion de pointeur :
Un registre Pointe sur une donnée
Ex : EDX contient l’adresse d’un entier
Déréférencement de pointeur :
Retrouver la valeur pointée
Ex : movl (%edx),%eax
Curseur sur un tableau contigu :
Un registre pointe sur une case
Passe à la suivante
Modes d’adressage complexes (2)Modes d’adressage complexes (2)
Adressage basé + déplacement :
Adressage basé plus un décalage fixe contenu dans le code opératoire
v = Mem(Registre+Offset)
Exemple :
movl %eax,12(%esp) \# Mem[SS:esp+12..esp+15]eax
movw -2(%ebx),%cx \# cx Mem[DS:ebx-2..ebx-1]
Adressage Basé+Depl. : Adressage Basé+Depl. : UtilisationsUtilisations
Utilisation commune : Gestion de la pileVariables locales / paramètres via EBP/ESP
movl -8(%ebp), %eax # variable n°2movl $15, (%esp) # paramètre n°1
Autre utilisation : les structuresVariable composée de plusieurs valeurs
Point = struct { short x,y; Couleur c }@Point.x = @Point, @Point.y = @Point+2, @Point.c = @Point+4
Point p; p.y =0movl $p,%ebxmovw $0, 2(%ebx)
Modes d’adressage complexes (3)Modes d’adressage complexes (3)
Adressage indexé :
Adressage basé plus un décalage contenu dans un registre
v = Mem(Registre+Registre)
Exemple :
# ecx contient 3
movb %al,(%ebx,%ecx) \# Mem[DS:ebx+ecx]al \# Mem[DS:ebx+3]al
Adressage indexé : UtilisationsAdressage indexé : Utilisations
Les chaînes / tableauxExemple : remplacer une valeur
T: .byte 1,2,3,4,5,6,7,8,9,0movl $T,%ebxmovl $0,%esi
Boucle:movb (%ebx,%esi),%al # charge la valeur dans aljz Fin # si 0, alors aller à Fincmpb $3,%al # compare à 3jne Suite # si ≠ aller à Suitemovb $-3, (%ebx,%esi) # sinon remplacer par -3
Suite:inc %esi # passe à la valeur suivantejmp Boucle # et recommence…
Fin:
Modes d’adressage complexes (4)Modes d’adressage complexes (4)
Adressage indexé + déplacement :
Adressage indexé plus un décalage fixe contenu dans le code opératoire
v = Mem(Registre+Registre+Offset)
Exemple :
# ecx contient 3
movb %al,4(%ebx,%ecx) \# Mem[DS:ebx+ecx+4]al \# Mem[DS:ebx+7]al
Adressage indexé+déplacement Adressage indexé+déplacement
Les tableaux de structuresExemple : afficher des noms/prénoms
struct etudiant {char* nom, prenom; int note};Promo: .long N1,P1,18, N2,P2,15, N3,P3,8 \ ,N4,P4,12, N5,P5,3, 0format: .string "étudiant %s (%s)\n"
movl $Promo,%ebxmovl $0,%esi
Boucle:pushl 4(%ebx,%esi) # empile prénompushl 0(%ebx,%esi) # empile nompushl $format # empile @ de ‘étudiant %s (%s)\n’call printfaddl $12,%esp # nettoie la pile (retirer 3 @ 32 bits)addl $12,%esi # passe au suivant (+12 octets)cmpb $0,(%ebx,%esi) # compare nom à 0jne Boucle # si ≠ boucler
Modes d’adressage complexes (5)Modes d’adressage complexes (5)
Adressage indexé + échelle :Adressage indexé + échelle fixe contenue dans le code opératoire
v = Mem(Registre+Registre*Echelle)Echelle =
1, 2, 4, ou 8Exemple :
# ecx contient 3movb %al,(%ebx,%ecx,2)\
# Mem[DS:ebx+ecx*2]al \# Mem[DS:ebx+6]al
Adressage indexé + échelle :Adressage indexé + échelle :
Les mêmes que l’adressage indexéPour tableaux de gros objets (2, 4, ou 8 octets)Exemple : tableau de double (8 octets)
T: .double 1.414,2,3.14,4,5,6.55957,7,8,9,10Fmt: .string "valeur %f\n"
movl $T,%ebxmovl $9,%esi
Boucle:fldl (%ebx,%esi,8) # charge la valeurfstpl 4(%esp) # stocke la valeur sur la pilemovl $Fmt,(%esp) # stocke le format sur la pile ‘%f\n’call printfdec %esi # passe à la valeur suivantejns Boucle # si ≥0, alors boucler
Fin:
Modes d’adressage complexes (6)Modes d’adressage complexes (6)
Adressage indexé + échelle + décalage :
Adressage indexé avec échelle et décalage fixes contenus dans le code opératoire
v = Mem(Registre + Registre*Echelle + Offset)
Exemple :
# ecx contient 3
movb %al,5(%ebx,%ecx,2)\ # Mem[DS:ebx+ecx*2+5]al \# Mem[DS:ebx+6+5]al \# Mem[DS:ebx+11] al
Modes d’adressage complexesModes d’adressage complexes
.dataC1: .ascii
"abcdefghi"C2: .string "%c\n"
.text
.macro affichemovzbl %al,%edxpushl %edxpushl $C2call printfaddl $8,%esp
.endm
.global startstart :
pushl %ebpmovl %esp,%ebp
movl $C1,%ebxmovb (%ebx),%alaffiche
‘a’
movl $3,%ecxmovb (%ebx,%ecx),%alaffiche
‘d’
movl $3,%ecxmovb (%ebx,%ecx,2),%alaffiche
‘g’
movl $3,%ecxmovb 1(%ebx,%ecx,2),%alaffiche
‘h’
Contenu du coursContenu du cours
Définition
Adressage simple
Note sur le stockage en mémoire
Adressage complexe
Note sur les segmentsNote sur les segments
Les segmentsLes segments
On utilise principalement 4 registres de segments :CS, DS, ES, SS
Par défaut :Toute instruction est lue dans CSTout accès indirect se fait dans DSTout accès basé sur e?x se fait dans DSTout accès basé sur e?p se fait dans SSToute fonction de chaîne se fait dans ES
On peut imposer le segment de son choix saufInstructions TOUJOURS dans CSChaînes TOUJOURS dans ES
Les segments (2)Les segments (2)
Aujourd’hui…Le mode segmenté n’est plus utiliséOn utilise le mode protégéEt plus particulièrement le modèle ‘flat’
La mémoire…Est accessible globalement…Linéairement…Sans utilisation visible des segmentsOn peut donc oublier le transparent précédent sans risque majeur….… sauf si on programme sans O.S. !
Définition
Adressage simple
Note sur le stockage en mémoire
Adressage complexe
Note sur les segments
ExercicesExercices
Exercice 1Exercice 1
movl \ $0x12345678,%eaxmovw %ax,%bxmovw %bx,%cxmovb %bh,%almovb %ah,%bhimul $0x10000,%ecxmovw %ax,%cx
# %eax = ??? # %ebx = ???# %ecx = ???
EAX=0x12345678
EBX=0x????5678ECX=0x????5678EAX=0x12345656EBX=0x????5678ECX=0x56780000ECX=0x56785656
Exercice 2Exercice 2
a: .long 1b: .short -1
movw a,%bxmovl a,%ecxmovl %ecx,%edxmovw b,%dxmovw %dx,2(a)movl 2(a),%edx
movw %cx,3(a)# a=? b=? # eax=? ebx=?# ecx=? edx=?
a:01000000b:FFFFEBX=0x????0001ECX=0x00000001=1EDX=0x00000001=1EDX=0x0000FFFFa:0100FFFFab:0100FFFFFFFFEDX=0xFFFFFFFF=-1ab=0x0100FFFFFFFF ->0x0100FF0100FFa=0x01FF0001b=0xFF00
Exercice 3Exercice 3
.set prix=0
.set qte=2Inv: .short 1,10.short 3,5.short 18,10Somme:
movl $2,%ecxmovl $Inv,%ebxmovl $0,%edx
Somme1:movw prix(%ebx,%ecx,4),%aximulw qte(%ebx,%ecx,4) ,%axaddl %eax,%edxdecl %ecxjns Somme1#edx = ?
ECX=2EBX=InvEDX=0
Somme1.1:AXMem[Inv+2*4+0]=18AX*=Mem[Inv+2*4+2]=10EDX+=EAX (EDX180)ECX-- (ECX1)
Somme1.2:AXMem[Inv+1*4+0]=3AX*=Mem[Inv+1*4+2]=5EDX+=EAX (EDX195)ECX-- (ECX0)EFLAGS.Z 1
Exercice 3 (2)Exercice 3 (2)
.set prix=0
.set qte=2Inv: .short 1,10.short 3,5.short 18,10Somme:
movl $2,%ecxmovl $Inv,%ebxmovl $0,%edx
Somme1:movw prix(%ebx,%ecx,4),%aximulw qte(%ebx,%ecx,4) ,%axaddl %eax,%edxdecl %ecxjns Somme1#edx = ?
EDX=195, ECX=0, EBX=InvEFLAGS.Z=1Somme1.3:
AXMem[Inv+0*4+0]=1AX*=Mem[Inv+0*4+2]=10EDX+=EAX (EDX205)ECX-- (ECX-1)EFLAGS.Z 0EFLAGS.S 1JNS ne saute pas… (S=1)
EDX=205EDX=prix1*qte1 +prix2*qte2 +prix3*qte3