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


Définition

Adressage simpleAdressage simple


Adressage complexe


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)


Définition

Adressage simple

Note sur le stockage en mémoireNote sur le stockage en mémoire

Adressage complexe



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


On aligne ses données

On aligne ses instructions


Définition

Adressage simple


Adressage complexeAdressage complexe


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


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)


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:


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


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:


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’


Définition

Adressage simple


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


Adressage complexe


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


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


.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

Mode d'adressage

Documents

Transcript of Mode d'adressage