Mode d'adressage

merci Laurent JEANPIERRE

Contenu du cours
Dfinition Adressage simple Note sur le stockage en mmoire Adressage complexe Note sur les segments

Dfinition

Les oprandes dune instruction peuvent tre exprimes de plusieurs faons : Directe (valeur immdiate) Indirecte (valeur dans une case mmoire) Registre (valeur dans un registre) Base (valeur indirecte via registre) Indexe (Base + Registre {+ Echelle}) Base/Indexe + dcalage

Cest ce que lon nomme des Modes dadressages

Contenu du cours
Dfinition Adressage simple Note sur le stockage en mmoire Adressage complexe Note sur les segments

Modes dadressage simples

Oprande 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 dadressage simples

Valeur immdiate Valeur fixe stocke dans le code opratoire Ex : movl $1,%eax # eax 1

Valeur indirecte Valeur stocke dans une case mmoire fixe v = Mem(adresse) Exemples : movl (1),%eax # eax Mem(DS:1..4) movw prix,%bx # bx Mem(DS:prix..prix+1)

Utilisation
Valeur immdiate Insertion de valeur dans un programme Valeur indirecte Accs une variable globale Accs une constante Registre Variable intermdiaire Stockage temporaire Rsultat de fonction (EAX) Gestion de la pile (EBP/ESP)

Contenu du cours
Dfinition Adressage simple Note sur le stockage en mmoire Adressage complexe Note sur les segments

Note sur le stockage en mmoire

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 mmoire : v: 01 02 03 04

Note sur le stockage en mmoire

On aligne ses donnes On aligne ses instructions

Contenu du cours
Dfinition Adressage simple Note sur le stockage en mmoire Adressage complexe Note sur les segments

Modes dadressage complexes (1)

Adressage bas : Valeur contenue en mmoire ladresse contenue dans un registre : v = Mem(Registre) Exemple : movl %eax,(%esp) # Mem[SS:esp..esp+3]eax Registres utilisables : eax,ebx,ecx,edx esp,ebp esi,edi (segment DS) (segment SS) (segment DS)

Adressage Bas : utilisations

Notion de pointeur : Un registre Pointe sur une donne Ex : EDX contient ladresse dun entier Drfrencement de pointeur : Retrouver la valeur pointe Ex : movl (%edx),%eax Curseur sur un tableau contigu : Un registre pointe sur une case Passe la suivante

Modes dadressage complexes (2)

Adressage bas + dplacement : Adressage bas plus un dcalage fixe contenu dans le code opratoire 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. : Utilisations

Utilisation commune : Gestion de la pile Variables locales / paramtres via EBP/ESP movl -8(%ebp), %eax # variable n2 movl $15, (%esp) # paramtre n1

Autre utilisation : les structures Variable compose 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 =0 movl $p,%ebx movw $0, 2(%ebx)

Modes dadressage complexes (3)

Adressage index : Adressage bas plus un dcalage 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 : Utilisations

Les chanes / tableaux Exemple : remplacer une valeur T: .byte 1,2,3,4,5,6,7,8,9,0 movl $T,%ebx movl $0,%esi Boucle: movb (%ebx,%esi),%al # charge la valeur dans al jz Fin # si 0, alors aller Fin cmpb $3,%al # compare 3 jne Suite # si aller Suite movb $-3, (%ebx,%esi) # sinon remplacer par -3 Suite: inc %esi # passe la valeur suivante jmp Boucle # et recommence Fin:

Modes dadressage complexes (4)

Adressage index + dplacement : Adressage index plus un dcalage fixe contenu dans le code opratoire 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+dplacement
Les tableaux de structures Exemple : afficher des noms/prnoms struct etudiant {char* nom, prenom; int note}; Promo: .long N1,P1,18, N2,P2,15, N3,P3,8 \ ,N4,P4,12, N5,P5,3, 0 format: .string "tudiant %s (%s)\n" movl $Promo,%ebx movl $0,%esi Boucle: pushl 4(%ebx,%esi) # empile prnom pushl 0(%ebx,%esi) # empile nom pushl $format # empile @ de tudiant %s (%s)\n call printf addl $12,%esp # nettoie la pile (retirer 3 @ 32 bits) addl $12,%esi # passe au suivant (+12 octets) cmpb $0,(%ebx,%esi) # compare nom 0 jne Boucle # si boucler

Modes dadressage complexes (5)

Adressage index + chelle : Adressage index + chelle fixe contenue dans le code opratoire v = Mem(Registre+Registre*Echelle) Echelle = 1, 2, 4, ou 8 Exemple : # ecx contient 3 movb %al,(%ebx,%ecx,2)\ # Mem[DS:ebx+ecx*2]al \ # Mem[DS:ebx+6]al

Adressage index + chelle :

Les mmes que ladressage 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,10 Fmt: .string "valeur %f\n" movl $T,%ebx movl $9,%esi Boucle: fldl (%ebx,%esi,8) # charge la valeur fstpl 4(%esp) # stocke la valeur sur la pile movl $Fmt,(%esp) # stocke le format sur la pile %f\n call printf dec %esi # passe la valeur suivante jns Boucle # si 0, alors boucler Fin:

Modes dadressage complexes (6)

Adressage index + chelle + dcalage : Adressage index avec chelle et dcalage fixes contenus dans le code opratoire 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 dadressage complexes

.data C1: .ascii "abcdefghi" C2: .string "%c\n" .text .macro affiche movzbl %al,%edx pushl %edx pushl $C2 call printf addl $8,%esp .endm .global start start : pushl %ebp movl %esp,%ebp

movl $C1,%ebx movb (%ebx),%al affiche a movl $3,%ecx movb (%ebx,%ecx),%al affiche d movl $3,%ecx movb (%ebx,%ecx,2),%al affiche g

movl $3,%ecx movb 1(%ebx,%ecx,2),%al affiche h

Contenu du cours
Dfinition Adressage simple Note sur le stockage en mmoire Adressage complexe Note sur les segments

Les segments
On utilise principalement 4 registres de segments : CS, DS, ES, SS Par dfaut : Toute instruction est lue dans CS Tout accs indirect se fait dans DS Tout accs bas sur e?x se fait dans DS Tout accs bas sur e?p se fait dans SS Toute fonction de chane se fait dans ES On peut imposer le segment de son choix sauf Instructions TOUJOURS dans CS Chanes TOUJOURS dans ES

Les segments (2)

Aujourdhui Le mode segment nest plus utilis On utilise le mode protg Et plus particulirement le modle flat La mmoire Est accessible globalement Linairement Sans utilisation visible des segments On peut donc oublier le transparent prcdent sans risque majeur. sauf si on programme sans O.S. !

Dfinition Adressage simple Note sur le stockage en mmoire Adressage complexe Note sur les segments Exercices

Exercice 1
movl movw movw movb movb imul movw \ $0x12345678,%eax %ax,%bx %bx,%cx %bh,%al %ah,%bh $0x10000,%ecx %ax,%cx
EAX=0x12345678 EBX=0x????5678 ECX=0x????5678 EAX=0x12345656 EBX=0x????5678 ECX=0x56780000 ECX=0x56785656

# %eax = ??? # %ebx = ??? # %ecx = ???

Exercice 2
a: .long 1 b: .short -1 movw a,%bx movl a,%ecx movl %ecx,%edx movw b,%dx movw %dx,2(a) movl 2(a),%edx

movw %cx,3(a) # a=? b=? # eax=? ebx=? # ecx=? edx=?

a:01000000 b:FFFF EBX=0x????0001 ECX=0x00000001=1 EDX=0x00000001=1 EDX=0x0000FFFF a:0100FFFF ab:0100FFFFFFFF EDX=0xFFFFFFFF=-1 ab=0x0100FFFFFFFF ->0x0100FF0100FF a=0x01FF0001 b=0xFF00

Exercice 3
.set prix=0 .set qte=2 Inv: .short 1,10 .short 3,5 .short 18,10 Somme: movl $2,%ecx movl $Inv,%ebx movl $0,%edx Somme1: movw prix(%ebx,%ecx,4),%ax imulw qte(%ebx,%ecx,4) ,%ax addl %eax,%edx decl %ecx jns Somme1 #edx = ?

ECX=2 EBX=Inv EDX=0 Somme1.1: AXMem[Inv+2*4+0]=18 AX*=Mem[Inv+2*4+2]=1 0 EDX+=EAX (EDX180) ECX-- (ECX1) Somme1.2: AXMem[Inv+1*4+0]=3 AX*=Mem[Inv+1*4+2]=5 EDX+=EAX (EDX195) ECX-- (ECX0) EFLAGS.Z 1

Exercice 3 (2)
.set prix=0 .set qte=2 Inv: .short 1,10 .short 3,5 .short 18,10 Somme: movl $2,%ecx movl $Inv,%ebx movl $0,%edx Somme1: movw prix(%ebx,%ecx,4),%ax imulw qte(%ebx,%ecx,4) ,%ax addl %eax,%edx decl %ecx jns Somme1 #edx = ?

EDX=195, ECX=0, EBX=Inv EFLAGS.Z=1 Somme1.3: AXMem[Inv+0*4+0]=1 AX*=Mem[Inv+0*4+2]=10 EDX+=EAX (EDX205) ECX-- (ECX-1) EFLAGS.Z 0 EFLAGS.S 1 JNS ne saute pas (S=1) EDX=205 EDX=prix1*qte1 +prix2*qte2 +prix3*qte3