Les modes d’adressage

Les modes d’adressage Laurent JEANPIERRE <jeanpl@iutc3.unicaen.fr> D’après le cours de Pascal FOUGERAY IUT de CAEN – Campus 3 Département Informatique

Contenu du cours • Définition • Adressage simple • Note sur le stockage en mémoire • Adressage complexe • Note sur les segments Département Informatique

Dé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épartement Informatique

Modes 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 Département Informatique

Modes d’adressage simples Valeur immédiate • Valeur fixe stockée dans le code opératoire • Ex : movl $1,%eax# eax  1 Valeur indirecte • Valeur 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) Département Informatique

Utilisation • 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épartement Informatique

Note 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 Département Informatique

Note sur le stockage en mémoireConclusion • On ne joue pas avec la mémoire • On aligne ses données • On aligne ses instructions • On peut enfreindre ces règles… • … exceptionnellement ! • On réfléchit deux fois avant d’enfreindre ces règles ! Département Informatique

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) Département Informatique

Adressage 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 Département Informatique

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] Département Informatique

Adressage Basé+Depl. : Utilisations Utilisation commune : Gestion de la pile • Variables locales / paramètres via EBP/ESP • movl -8(%ebp), %eax # variable n°2 • movl $15, (%esp) # paramètre n°1 Autre utilisation : les structures • Variable 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 =0 • movl $p,%ebx • movw $0, 2(%ebx) Département Informatique

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 Département Informatique

Adressage indexé : Utilisations • Les chaînes / 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: Département Informatique

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 Département Informatique

Adressage indexé+déplacement Utilisations • Les tableaux de structures • Exemple : 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, 0 format: .string "étudiant %s (%s)\n" movl $Promo,%ebx movl $0,%esi Boucle: pushl 4(%ebx,%esi) # empile prénom 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 Département Informatique

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 8 • Exemple : • # ecx contient 3 • movb %al,(%ebx,%ecx,2)\# Mem[DS:ebx+ecx*2]al \ # Mem[DS:ebx+6]al Département Informatique

Adressage indexé + échelle :Utilisations • 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,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: Département Informatique

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 Département Informatique

.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,%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’ Modes d’adressage complexesExemple Département Informatique

Les segments • On utilise principalement 4 registres de segments : • CS, DS, ES, SS • Par défaut : • Toute instruction est lue dans CS • Tout accès indirect se fait dans DS • Tout accès basé sur e?x se fait dans DS • Tout accès basé sur e?p se fait dans SS • Toute fonction de chaîne se fait dans ES • On peut imposer le segment de son choix sauf • Instructions TOUJOURS dans CS • Chaînes TOUJOURS dans ES Département Informatique

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 segments • On peut donc oublier le transparent précédent sans risque majeur…. • … sauf si on programme sans O.S. ! Département Informatique

Contenu du coursEt bien… c’est pas fini ? • Définition • Adressage simple • Note sur le stockage en mémoire • Adressage complexe • Note sur les segments • Exercices Département Informatique

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

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:0100FFFFFFFFEDX=0xFFFFFFFF=-1 ab=0x0100FFFFFFFF ->0x0100FF0100FFa=0x01FF0001b=0xFF00 Exercice 2 Département Informatique

.set prix=0.set qte=2Inv: .short 1,10.short 3,5.short 18,10Somme: movl $2,%ecx movl $Inv,%ebx movl $0,%edxSomme1: 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: AXMem[Inv+2*4+0]=18 AX*=Mem[Inv+2*4+2]=10 EDX+=EAX (EDX180) ECX-- (ECX1) Somme1.2: AXMem[Inv+1*4+0]=3 AX*=Mem[Inv+1*4+2]=5 EDX+=EAX (EDX195) ECX-- (ECX0)EFLAGS.Z  1 Exercice 3 Département Informatique

.set prix=0.set qte=2Inv: .short 1,10.short 3,5.short 18,10Somme: movl $2,%ecx movl $Inv,%ebx movl $0,%edxSomme1: 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: AXMem[Inv+0*4+0]=1 AX*=Mem[Inv+0*4+2]=10 EDX+=EAX (EDX205) ECX-- (ECX-1)EFLAGS.Z  0EFLAGS.S  1 JNS ne saute pas… (S=1) EDX=205 EDX=prix1*qte1 +prix2*qte2 +prix3*qte3 Exercice 3 (2) Département Informatique

Les modes d’adressage