merci Laurent JEANPIERRE

Slides:



Advertisements
Présentations similaires
Premier programme en C :
Advertisements

Chap. 4 Recherche en Table
Les procédures et interruptions en Assembleur (Tasm)
ARCHITECTURE INTERNE d’un MICROPROCESSEUR
1Deug 1 Systèmes d Information : 7a Michel de Rougemont Université Paris II Les tableurs : Excel.
C++ 6ème cours Patrick Reuter maître de conférences
Hiver 2010JGA Beaulieu GEF 243B Programmation informatique appliquée Tableaux et pointeurs §10.1.
Plan du cours : 2ème Partie
Jacques Lonchamp IUT Nancy Charlemagne – DUT Informatique 1A
Programmation assembleur : aperçu
Assembleur
La pile un élément essentiel
Ref :
Exemple de compilation
C.
Le jeu d ’instructions Introduction Un jeu d ’instruction classique
Les structures de données
Chap. 1 Structures séquentielles : listes linéaires
FLSI602 Génie Informatique et Réseaux
8. Les tableaux P. Costamagna – ISEN N1.
Architecture de machines Le microprocesseur
Système d’exploitation : Assembleur
Système d’exploitation : Assembleur
B.Shishedjiev - Informatique II
Système d’exploitation : Assembleur
Système d’exploitation : Assembleur
Système d’exploitation : Assembleur
Les piles Djamal Rebaïne.
La récursivité Une procédure est dite récursive si, et seulement si, elle fait appel à elle-même, soit directement soit indirectement Djamal Rebaïne Djamal.
Système d’exploitation : Assembleur
LE MICROPROCESSEUR 8086/8088 Architecture externe du 8086
Architecture des Ordinateurs
Quest-ce quune classe dallocation? Une classe dallocation détermine la portée et la durée de vie dun objet ou dune fonction.
Sécurité et Buffer Overflow
Programmation Initiation Aux Langages C et C++ (2) Bruno Permanne 2006.
Les pointeurs Modes d’adressage de variables. Définition d’un pointeur. Opérateurs de base. Opérations élémentaires. Pointeurs et tableaux. Pointeurs et.
Structures de données IFT-2000
Architecture et technologie des ordinateurs II
IFT 6800 Atelier en Technologies d’information
8PRO100 Éléments de programmation Les types composés.
Texture 2D en PGC++.
Tableaux Introduction aux tableaux à une dimension. Déclaration, stockage, initialisation et accès en lecture ou en écriture aux composantes d’un tableau.
L’essentiel du langage C
Structures des données
Processeur modèle 8086 David Saint-Mellion.
Les bases de l’assembleur
Le langage C Rappel Pointeurs & Allocation de mémoire.
Traitement des tableaux et chaînes de caractères
Notions de pointeurs en C
Architecture Des Ordinateurs Microprocesseur Et Mémoire
et quelques rappels sur certains éléments du langage C
ALGORITHMIQUE ET PROGRAMMATION C
Architecture interne du microprocesseur 8086.
Un survol du language C.
1 Structures des données. 2  Le tableau permettait de désigner sous un seul nom un ensemble de valeurs de même type, chacune d'entre elles étant repérée.
Architectures des ordinateurs
Les types composés Les enregistrements.
1 École des Mines de Saint-Etienne. 158, cours Fauriel Saint-Etienne Cedex 2. tél Fax Cours Architecture des.
Cours LCS N°4 Présenté par Mr: LALLALI
Patricia Renault UPMC 2005/2006
8PRO107 Éléments de programmation Les adresses et les pointeurs.
PRO-1027 Programmation Scientifique en C
Tour rapide d’un premier programme SPARC v9
Chapitre 3 L’accès aux données.

CHAPITRE 10 Les sous-programmes 1. Sous-programme Suite d’instructions appelée de manière répétitive Par un programme Par plusieurs programmes distincts.
Département Informatique Les modes d’adressage Laurent JEANPIERRE D’après le cours de Pascal FOUGERAY IUT de CAEN – Campus 3.
Département Informatique Gestion du flux d’exécution Laurent JEANPIERRE D’après le cours de Pascal FOUGERAY IUT de CAEN – Campus 3.
Assembleur
Transcription de la présentation:

merci Laurent JEANPIERRE Mode d'adressage merci Laurent JEANPIERRE

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

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

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

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 movz zero movs signextention

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)

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)

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

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

Note sur le stockage en mémoire On aligne ses données On aligne ses instructions

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

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) S segment

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

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]

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)

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

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:

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

Adressage indexé+déplacement 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

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

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,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 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

Modes d’adressage 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 Définition Adressage simple Note sur le stockage en mémoire Adressage complexe Note sur les segments

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

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éfinition Adressage simple Note sur le stockage en mémoire Adressage complexe Note sur les segments Exercices

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 ECX=0x56780000 ECX=0x56785656

Exercice 2 a: .long 1 b: .short -1 a:01000000 movw a,%bx b:FFFF 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: 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 (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