Département Informatique Les modes d’adressage Laurent JEANPIERRE D’après le cours de Pascal FOUGERAY IUT de CAEN – Campus 3.

Présentation au sujet: "Département Informatique Les modes d’adressage Laurent JEANPIERRE D’après le cours de Pascal FOUGERAY IUT de CAEN – Campus 3."— Transcription de la présentation:

1 Département Informatique Les modes d’adressage Laurent JEANPIERRE D’après le cours de Pascal FOUGERAY IUT de CAEN – Campus 3

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

3 Département Informatique 3 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 des Modes d’adressages

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

5 Département Informatique 5 Modes d’adressage simples Opérande Registre Valeur contenue dans un registre v = Registre Exemples : # al contient -1 = 255 = 11111111 2 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

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

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

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

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

10 Département Informatique 10 Note sur le stockage en mémoire Conclusion 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 !

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

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

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

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

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

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

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

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

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

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

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

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

23 Département Informatique 23 Modes d’adressage complexes Exemple.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’

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

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

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

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

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

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

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

31 Département Informatique 31 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: AX  Mem[Inv+0*4+0]=1 AX*=Mem[Inv+0*4+2]=10 EDX+=EAX (EDX  205) ECX-- (ECX  -1) EFLAGS.Z  0 EFLAGS.S  1 JNS ne saute pas… (S=1) EDX=205 EDX=prix1*qte1 +prix2*qte2 +prix3*qte3