1 / 31

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. Contenu du cours. Définition Adressage simple Note sur le stockage en mémoire Adressage complexe Note sur les segments. Définition.

kathryn
Download Presentation

Les modes d’adressage

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript


  1. 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

  2. Contenu du cours • Définition • Adressage simple • Note sur le stockage en mémoire • Adressage complexe • Note sur les segments 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 desModes d’adressages Département Informatique

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

  5. 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

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

  8. Contenu du cours • Définition • Adressage simple • Note sur le stockage en mémoire • Adressage complexe • Note sur les segments 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 Département Informatique

  10. 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

  11. Contenu du cours • Définition • Adressage simple • Note sur le stockage en mémoire • Adressage complexe • Note sur les segments 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) 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 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] 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) 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 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: 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 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 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 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: 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 Département Informatique

  23. .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

  24. Contenu du cours • Définition • Adressage simple • Note sur le stockage en mémoire • Adressage complexe • Note sur les segments 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 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. ! Département Informatique

  27. 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

  28. 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

  29. 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

  30. .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

  31. .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

More Related