PureBasic

Forums PureBasic
Nous sommes le Dim 22/Sep/2019 23:42

Heures au format UTC + 1 heure




Poster un nouveau sujet Répondre au sujet  [ 2 messages ] 
Auteur Message
 Sujet du message: Tutoriel 5 - Les registres des microprocesseurs 32 bits X86
MessagePosté: Ven 26/Nov/2004 16:32 
Hors ligne
Avatar de l’utilisateur

Inscription: Jeu 22/Jan/2004 14:31
Messages: 3518
Localisation: Sourans
Code:
Tutoriel 5 - Les registres des microprocesseurs 32 bits de la famille X86.
--------------------------------------------------------------------------

Par Denis



LES REGISTRES :
---------------

  A) Registres généraux 32 bits (ou registres de travail):
  --------------------------------------------------------
    Ils sont quatre.
 
     EAX appelé aussi accumulateur
 
     EBX appelé aussi registre de base
 
     ECX appelé aussi registre compteur
 
     EDX appelé aussi registre de données
 
 
  EAX est un registre très utilisé. En PureBasic, eax est utilisé pour retourner le résultat d'une procédure.
  Il est également utilisé pour le passage de paramètre lorsque l'appel n'est pas en Standart call.
  Les API Windows retournent souvent le résultat de la fonction et c'est dans EAX sauf mention contraire.
 
  Ces 4 registres peuvent être décomposés en registre 16 bits et en registre 8 bits directement utilisables avec les instructions asm.
 
  Voici la décomposition pour EAX (décomposition identique pour les 3 autres registres).
 
  (rappel : b0 veut dire bit 0 (LSB) et b31 bit 31 (MSB))
 
   
b31                              b0
   _______________________________
  |                               |
  |              EAX              |  <-- 32 bits
  |_______________________________|
                 |                |
                 |       AX       |  <-- 16 bits (poids faible uniquement)
                 |________________|
                 |        |       |
                 |   AH   |   AL  |  <-- 8 bits  et 8 bits
                 |________|_______|

 
  On peut accéder aux 16 bits de poids faible du registre EAX. Ce registre de 16 bits se nomme AX.
  A noter qu'il n'y a pas de registre correspondant aux 16 bits de poids fort de EAX.
 
  AX peut à son tour être divisé en 2 registres 8 bits distincts.
    Le registre de 8 bits de poids fort de AX se nomme AH, H comme High.
    Le registre de 8 bits de poids faible de AX se nomme AL, L comme Low.
   
   
   
  Bien que EAX puisse être découpé en différentes tailles, il s'agit du même registre.
  Toute modification de valeur sur AL ou AH modifie AX et EAX etc.
  Seul AH et AL sont indépendants, si on modifie AH, cela n'affecte pas AL et réciproquement.
  Les registres AH et AL peuvent être utilisés pour manipuler des valeurs sur un octet (code moins encombrant).
   
   
  La décomposition des autres registres généraux est la même
 
 
  EBX en BX (16 bits), en BH (8 bits) et BL (8 bits)
 
  ECX en CX (16 bits), en CH (8 bits) et CL (8 bits)

  EDX en DX (16 bits), en DH (8 bits) et DL (8 bits)

  Certaines instructions sont plus rapides avec l'accumulateur EAX qu'avec d'autres registres.
 
  Ces registres peuvent être utilisés pour manipuler des données, faire des opérations logiques, des comparaisons, pour stocker provisoirement une valeur etc.
  Certaines instructions utilisent certains de ces registres et pas d'autres.
 
  EAX et EDX sont utilisés par des instructions de multiplication et de division.
 
  ECX est utilisé comme compteur de boucle par certaines instructions (LOOP, LOOPE etc.).
 
 
  B) Registres d'index 32 bits (ou de déplacement) :
  --------------------------------------------------
    Ils sont deux.
 
     EDI appelé aussi registre d'index de destination étendu.
 
     ESI appelé aussi registre d'index de source étendu.
 
   
Ces 2 registres peuvent être décomposés en registre 16 bits utilisables avec les instructions asm.
Ils ne sont pas décomposables en registre 8 bits.
 
  Voici la décomposition pour EDI (décomposition identique pour ESI).
 
 
   
b31                              b0
   _______________________________
  |                               |
  |              EDI              |  <-- 32 bits
  |_______________________________|
                 |                |
                 |       DI       |  <-- 16 bits (poids faible uniquement)
                 |________________|
 


  Ces registres sont utilisés avec des instructions de manipulations de chaînes (MOVS, LODS etc.).
  On peut très bien utiliser ces registres pour d'autres opérations classiques sur les registres (stockage, empilement etc.).


  C) Registre de base 32 bits EBP:
  --------------------------------
   EBP peut aussi être décomposé en un registre de 16 bits (BP) qui correspondent aux 16 bits de poids faible de EBP.
   Ce registre est le plus souvent utilisé comme référence d'adresse des données passées sur la pile.
   Il peut aussi être utilisé comme un registre classique.


  D) Registre d'instruction 32 bits EIP:
  --------------------------------------
   EIP contient l'adresse de la prochaine instruction qui sera exécutée par le µp.
   Il est possible de modifier sa valeur mais c'est à utiliser avec précaution et vraiment si c'est utile.
   Une mauvaise valeur dans EIP et c'est le plantage assuré!


  E) Registre 32 bits ESP, pointeur de pile :
  -------------------------------------------
   Ce registre sert à gérer les données sur la pile, il contient une adresse.
   Il peut être utilisé à la place de EBP pour référencer les données passées sur la pile ainsi que pour les variables locales.
   Sa manipulation sur de long programme n'est pas aisée car ESP change souvent de valeur. Nous verrons cela plus en détail dans le prochain tut.
   
   
  F) Registres de segment 16 bits:
  --------------------------------
   Ces registres contiennent l'adresse de début (ou de base) d'un segment qui est une zone mémoire.
   Il peut s'agir d'un segment de code (cette zone mémoire contient du code) ou d'un segment de données (cette zone mémoire contient des données type variables ) ou d'un segment de pile (cette zone mémoire contient les adresses de retour de sous-programmes, paramètres des fonctions, les variables locales).
   En général, nous ne manipulerons pas ces registres directement.

   CS est le registre de segment de code. On peut fixer ou connaître l'adresse de début des instructions d'une application.

   DS est le registre de segment de données. Ce registre sert à accéder aux données.

   ES ou registre de segment extra, (utilisé pour les opérations sur les chaînes).

   FS Idem à ES.

   GS Idem à ES.

   SS est le registre de segment de pile.


  G) Registre  de drapeaux EFLAGS (32 bits):
  -----------------------------------------
  Ce registre de 32 bits est un indicateur de résultat de la dernière opération exécutée par le µp.
  On l'appelle aussi registre d'état.
  La plupart des instructions modifient ce registre. C'est ce registre qui sera utilisé par les instructions de saut, pour savoir aussi si une opération arithmétique a une retenue etc.
  Certains bits de ce registre peuvent être forcés à une valeur (0 ou 1). On dit qu'un bit de drapeau est armé lorsqu'il est à 1.
  Une partie des 32 bits sont réservés au système.
 
  On parle souvent de Flag qui est le mot anglais pour drapeau.
 
  Voici les bits b0 à b15 qui sont les bits de drapeaux.
 
 
b15                                              b0
  _________________________________________________
  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
  |15|14|13|12|11|10| 9| 8| 7| 6| 5| 4| 3| 2| 1| 0|
  |__|__|__|__|__|__|__|__|__|__|__|__|__|__|__|__|
  |  |  |     |  |  |  |  |  |  |  |  |  |  |  |  |
  |0 |NT|IOPL |OF|DF|IF|TF|SF|ZF|0 |AF|0 |PF|1 |CF|
  |__|__|_____|__|__|__|__|__|__|__|__|__|__|__|__|
 

  Voici les bits b16 b31.
 
b31                                               b16
  __________________________________________________
  |  |  |  |  |  |  |  |  |  |  |  |   |   |  |  |  |
  |31|30|29|28|27|26|25|24|23|22|21|20 |19 |18|17|16|
  |__|__|__|__|__|__|__|__|__|__|__|___|___|__|__|__|
  |  |  |  |  |  |  |  |  |  |  |  |   |   |  |  |  |
  |0 |0 |0 |0 |0 |0 |0 |0 |0 |0 |ID|VIP|VIF|AC|VM|RF|
  |__|__|__|__|__|__|__|__|__|__|__|___|___|__|__|__|



  Nous ne regarderons que les 16 premiers bits. Les bits b1, b3, b5 et b15 ne sont pas utilisés.
   

  On distingue 2 types de bits :
  ------------------------------
   Les bits d'état et les bits de contrôle/programmation
 
    Les bits d'état:
    ----------------
      Ils sont modifiés par certaines instructions de tests, d'opérations logiques etc.
   
      J'indique lorsque ces bits sont mis à 1. Dans les autres cas, ils sont mis à 0.
      Parfois ces bits peuvent être indéfinis, la documentation le précise.
 
     
      CF :
      ----
        C'est l'indicateur de retenue (Carry Flag) -  Ce flag est à 1 s'il y a une retenue lors d'une opération arithmétique non signée.
        En clair si par exemple on additionne sur un octet (8 bits) 245 et 30 ce qui donne 275 mais un octet non signé ne peut dépasser 255.
        Idem sur 16 ou 32 bits

      PF :
      ----
        C'est l'indicateur de parité (Parity Flag) - Ce flag est à 1 si le résultat contient est un nombre pair de bits à 1 dans l'octet de poids faible.
       
      AF :
      ----
        C'est l'indicateur auxiliaire (Auxiliary Flag), appelé aussi retenue auxiliaire.
        Ce flag est à 1 lorsqu'il y a un débordement en BCD (binaire codé décimal) au-delà du 3ème bit.

      ZF :
      ----
        C'est l'indicateur de zéro (Zero Flag) - Ce flag est à 1 lorsque le résultat est zéro.
        Lorsque le résultat est différent de 0, ce flag est à 0
               
      SF :
      ----
        C'est l'indicateur de signe (Sign Flag) - Ce flag est à 1 lorsque le résultat est négatif.
        Lorsque le résultat est positif, le flag est à 0. Ce flag recopie le bit le plus significatif (MSB)

      OF :
      ----
        C'est l'indicateur de dépassement de capacité sur les nombres signés (Overflow Flag).
        Ce flag est à 1 lorsqu'il y a un débordement de la capacité du registre après une opération sur des nombres signés.
        Ce dépassement va modifier le bit de signe.
       
       
    Les bits de contrôle/programmation:
    -----------------------------------
       
      TF :
      ----
        C'est le drapeau du mode pas à pas (trace - Trap Flag).
        Il faut le positionner pour valider ce mode.
 
      If :
      ----
        C'est le drapeau d'autorisation des Interruptions masquables (Interrupt enable).
        On le positionne pour autoriser le traitement des interruptions masquables.
 
      DF :
      ----
        C'est le drapeau de direction (Direction Flag).
        Il est utilisé pour les le sens (incrémentation ou décrémentation) sur les opérations de chaînes.
        Par exemple, avec l'instruction MOVS, si le flag est à 1 les registres DI et SI sont décrémentés.
        S'il est à 0, ces registres sont incrémentés.

      IOPL :
      ----
        C'est le drapeau de niveau de privilège des entrées/sorties (I/O Privilege Level).

      NT :
      ----
        C'est le drapeau de tâche chaînée (Nested Task Flag).
        Indique si la tâche courante est liée à une tâche parent par un CALL ou une interruption.


  H) Registres 80 bits de la FPU :
  --------------------------------
     Ils sont huit et sont utilisés pour les nombres à virgule flottante.
     De ST0 à ST7.
     
     La FPU comporte également 2 registres pointeurs sur 48 bits, un pour les instructions et un pour les données ainsi qu'un registre d'opcode.

  I) Registres particuliers :
  ---------------------------
     L'énumération des registres suivants est rapide. Nous n'utiliserons pas ces registres.
 
     - Registres de contrôle CR0 à CR4 (Control Register).
       CR1 est entièrement réservé et n'est pas utilisé par le programmeur.
       Certains bits de ces registres sont également réservés.
       
     - Registres de mise au point DR0 à DR7 (Debug Register).

     - Registres de test TR3 à TR7 (Test Register).
       
     - Registres de la table de descripteur Global GDTR (Global Descriptor Table Register).

     - Registres de la table de descripteur d'interruptions IDTR (Interrupt Descriptor Table Register).

     - Registres de la table de descripteur local LDTR (Local Descriptor Table Register).

     - Registres de tâches TR (Task Register).

     - Registres de datation TSC (Time Stamp Counter).
       Ce registre accumule le nombre de cycles d'horloge depuis le démarrage de l'ordi ou depuis le dernier reset.

     - Registres 64 bits MMX de MM0 à MM7.
   
     - Registres 128 bits SIMD de XMM0 à XMM7.
   


Prochain tut : Fonctionnement de la pile et les instructions asm pouvant la modifier.
               

A+
Denis


Haut
 Profil  
Répondre en citant le message  
 Sujet du message: Re: Tutoriel 5 - Les registres des microprocesseurs 32 bits X86
MessagePosté: Dim 03/Jan/2010 6:26 
Hors ligne

Inscription: Dim 11/Mai/2008 7:27
Messages: 61
Quelques notes :

Les registres MM(0,1,2,3,4,5,6,7) des instructions MMX sont en fait les memes registres de la FPU ST(0,1,2,3,4,5,6,7).
Il faut donc eviter de mixer instruction FPU et instruction MMX. A moins de vraiment savoir ce qu'on fait :)

Avec SSE2 on peut utiliser les Instruction MMX avec les registre specifiques a SSE : XMM(0,1,2,3,4,5,6,7)

on peut donc faire un :
Code:
MOVQ mm1, toto   <- instruction mmx sur les registre mmx

ou :
Code:
MOVQ xmm1, toto  <- instruction mmx sur les registre xmm


Haut
 Profil  
Répondre en citant le message  
Afficher les messages postés depuis:  Trier par  
Poster un nouveau sujet Répondre au sujet  [ 2 messages ] 

Heures au format UTC + 1 heure


Qui est en ligne

Utilisateurs parcourant ce forum: Aucun utilisateur enregistré et 2 invités


Vous ne pouvez pas poster de nouveaux sujets
Vous ne pouvez pas répondre aux sujets
Vous ne pouvez pas éditer vos messages
Vous ne pouvez pas supprimer vos messages

Rechercher:
Aller à:  
cron

 


Powered by phpBB © 2008 phpBB Group | Traduction par: phpBB-fr.com
subSilver+ theme by Canver Software, sponsor Sanal Modifiye