Le jeu d'instructions du 8086/8088

I ) introduction :

On peut diviser les instructions du 8086/88 en 6 groupes comme suit :

II ) Les instructions de transfert de données :

Ils sont divisés en 4 sous- groupes comme le montre le tableau suivant :

II-1 ) Les instructions d'usage général :

II-1-1 ) MOV :

Elle  permet  de  transférer  les  données  (un  octet  ou  un  mot)  d'un registre à un autre registre ou d'un registre à une case mémoire, sa syntaxe est comme suit :

Exemples :
MOV destination, source
MOV   AX, BX     ;  Transfert d'un registre de 16 bits vers un registre de 16 Bits
MOV   AH, CL     ;  Transfert d'un registre de 8 bits vers un registre de 8 bits
MOV   AX, Val1   ; Transfert du contenu d'une case mémoire 16 bits vers AX 
MOV   Val2, AL   ; Transfert du contenu du AL vers une case mémoire  D'adresse Val2
Remarques :
 MOV    Val1, Val2

Pour remédier à se problème on va effectuer cette opération sur deux étapes :

MOV AL, Val2
MOV Val1, AL
MOV   DS, ES

On va passer comme la première instruction :

MOV   AX, ES 
MOV   DS, DS

II-1-2 ) PUSH :

Elle permet d'empiler les registres du CPU sur le haut de la pile

Syntaxe : PUSH  SOURCE

Exemple :

II-1-3 ) POP :

Elle permet de dépiler les registres du CPU sur le haut de la pile

Syntaxe : POP  destination
Exemple :

II-1-4 ) PUSHA :

Cette  instruction  permet  d'empiler  la  totalité  des  registres internes du microprocesseur sur la pile.

II-1-5 ) POPA :

Cette  instruction  permet  de  dépiler  la  totalité  des  registres internes du microprocesseur sur la pile.

II-1-6 ) XCHG :

Elle permet de commuter la source avec la destination comme suit :

II-1-7 ) XLAT :

Cette instruction est utilisée pour convertir des données d'un code à un autre, en effet elle permet de placer dans l'accumulateur AL le contenu de la case mémoire adressée en adressage base+décalage (8 bits), la base étant le registre BX et le décalage étant AL lui même dans le segment DS

  (AL)<--------[ (BX) + (AL) ]

Syntaxe : XLAT tab_source

Exemple :

conversion du code binaire 4 bits en un digit hexa codé en ASCII

Tab  db     ‘0123456789ABCDEF'
MOV AL,1110B        ; chargement de la valeur à convertir (07) MOV BX, OFFSET TAB    
                    ; pointé sur le tableau
XLAT                ; Al est chargé par le code ASCII de ‘E'

II - 2 ) les instructions d'entrées-sorties :

II-2-1 ) IN ) OUT:

Elle permet de récupérer des données d'un port (donc de la périphérie) ou restituer des données à un port, dans les deux cas s'il s'agit d'envoyer ou de recevoir un octet on utilise l'accumulateur AL, s'il s'agit d'envoyer ou de recevoir un mot on utilise l'accumulateur AX.

Syntaxe :    

IN ACCUMULATEUR, DX
OUT DX, ACCUMULATEUR
Remarque :

DX : contient l'adresse du port.

ACCUMULATEUR : contient la donnée (à recevoir ou à emmètre).

II-3 /  Les instructions de transfert d'adresses :

II-3-1 ) LEA (Load Effective Address):

Elle transfert l'adresse offset (décalage) d'une opérande mémoire dans un registre de 16 bits (pointeur ou index). Cette commande a le même rôle que l'instruction MOV avec offset mais elle  est  plus  puissante  car  on  peut  utiliser  avec  elle  toute  technique d'adressage.

Exemple :

LEA BX, TAB_VAL (c'est équivalent à MOV BX, offset TAB_VAL)

II-3-2 ) LDS ) LES :

Cette instruction permet de charger le segment et l'offset d'une adresse

Exemple :

Au lieu de faire :

MOV   BX, offset tab_val 
MOV   AX , Seg tab_val 
MOV  DS , AX

On remplace ces trois instructions par une seule :

LDS BX , tab_val ;elle   charge   automatiquement l'offset de tab_val dans le registre BX 
                 ;et le segment dans le registre DS .
Remarque :

Pour l'instruction LES : le segment est ES.

II-4 ) Les instructions d'indicateur :

II-4-1 ) LAHF  ) SAHF :

LAHF : Load AH from Flags : place l'octet de poids faible du registre d'état (FLAGS) dans le registre AH comme suit :

SAHF : Store AH into Flags : Place le contenu de AH dans l'octet de poids faible du registre d'état (FLAGS).

II-4-2 ) PUSHF ) POPF:

PUSHF : Permet d'empiler  la totalité du  registre d'état (FLAGS)

POPF : Permet de dépiler le registre d'état (FLAGS).

III ) Instructions arithmétiques :

Les  instructions  arithmétiques  peuvent  manipuler  quatre  types  de nombres :

Les instructions arithmétiques sont divisées en quatre sous-groupes comme le montre le tableau suivant :

III-1 ) Addition :

III-1-1 ) ADD: (Addition)

Syntaxe :    ADD   Destination, source

Elle permet d'additionner le contenu de la source (octet ou un mot) avec celui de la destination le résultat est mis dans la destination

  Destination <---------- Destination  +  source
Exemples :
ADD AX, BX  ; AX = AX + BX (addition sur 16 bits) ADD  AL,BH      
            ; AL = AL + BH (addition sur 8 bits )
ADD AL, [SI]  ; AL = AL + le contenu de la case mémoire
              ; pointé par SI
ADD [DI], AL ; le contenu de la case mémoire pointé par DI
             ; Est additionnée avec AL, le résultat est mis
             ; dans la case mémoire pointé par DI
Remarques :
Exemples :
ADD Tab1 , Tab2


sera remplacé par : 

MOV AX , Tab2
ADD Tab1 , AX

III-1-2 ) ADC : (Addition avec retenue)

Syntaxe :    ADC   Destination, source

Elle permet d'additionner le contenu de la source (octet ou un mot) avec celui de la destination et la retenue (CF) le résultat est mis dans la destination

  Destination  <------------   Destination  +  source + retenue
Exemples :
ADC AX,BX   ; AX = AX + BX + CF(addition sur 16 bits ) 
ADC AL,BH   ; AL = AL + BH + CF(addition sur 8 bits ) 
ADC AL,[SI] ; AL = AL + le contenu de la case mémoire pointé par SI + CF
ADC [DI],AL ; le contenu de la case mémoire pointé par DI
            ; est additionné avec AL + CF , le résultat est
            ; mis dans  la case mémoire pointé par DI
Remarque :

Les restrictions de l'instruction ADD sont valables pour l'instruction ADC.

III-1-3 ) INC : (Incrémentation)

Syntaxe :    INC    Destination

Elle permet d'incrémenter le contenu de la destination

  Destination <----------  Destination  +  1
Exemples :
INC AX     ; AX = AX +  1 (incrémentation sur 16  bits). 
INC AL     ; AL = AL +1 (incrémentation sur 8 bits).
INC [SI]   ; [SI] = [SI] + 1 le contenu de la case mémoire pointé  par SI sera incrémenter
Remarque :

On ne peut pas incrémenter une valeur immédiate.

III-1-4 ) AAA ) DAA : ( ASCII ) DECIMAL Adjust for Addition )

L'addition de deux nombres BCD génére parfois un résultat qui n'est pas un nombre en BCD d'ou il faut faire des corrections sur ces nombres pour avoir un résultat cohérent. Cette instruction examine le quarte bas de AL et vérifie s'il est conforme ou non :

-     Si oui (elle met AF et CF à zéro pour information) efface la quarter haut de AL

-     Si non :

Exemples : on veut faire l'addition en BCD de 73 + 88

On remarque que ni 1111 ni 1011 est un nombre BCD donc on va ajouter 6

au premier quarte d'ou l'opération devient :

L'octet le plus haut :

d'ou les résultat 163

III-2 ) Soustraction :

III-2-1 ) SUB : (Soustraction)

Syntaxe :    SUB   Destination, source

Elle permet de soustraire  la destination de la source (octet ou un mot)  le résultat est mis dans la destination

  Destination <---------  Destination  --  source
Exemples :
SUB AX,BX    ; AX = AX - BX (Soustraction sur 16 bits )
SUB  AL,BH   ; AL = AL - BH ( Soustraction sur 8 bits )
SUB AL,[SI]  ; AL = AL - le contenu de la case mémoire pointé par SI
SUB [DI],AL  ; le contenu de la case mémoire pointé par DI
             ; est soustraite de AL , le résultat est mis
             ; dans la case mémoire pointé par DI
Remarques :

III-2-2 ) SBB : (Soustraction avec retenue)

Syntaxe :    SBB   Destination, source

Elle  permet  de  soustraire    la  destination  de  la  source  et  la retenue (octet ou un mot)  le résultat est mis dans la destination

 Destination <--------   Destination  --  source -- retenue
Exemples :
SBB AX,BX    ; AX = AX-BX - CF (Soustraction sur 16 bits ) 
SBB  AL,BH   ; AL = AL - BH - CF( Soustraction sur 8 bits ) 
SBB AL,[SI]  ; AL = AL - le contenu de la case mémoire
             ; pointé  par SI - CF
SBB [DI],AL  ; le contenu de la case mémoire pointé par DI
             ; est  soustraite avec AL - CF, le résultat est
             ; mis dans  la case mémoire pointé par DI
Remarques :

III-2-3 ) DEC : (Décrémentation)

Syntaxe :    DEC   Destination

Elle permet de décrémenter le contenu de la destination

  Destination   <----------- Destination  -  1
Exemples :
DEC AX    ; AX = AX -  1 (décrémentation sur 16  bits). 
DEC  AL   ; AL = AL -1 (décrémentation sur 8 bits). 
DEC [SI]  ; [SI] = [SI] - 1 le contenu de la case mémoire
          ; pointé  par SI sera décrémenter
Remarque :

On ne peut pas décrémenter une valeur immédiate.

III-2-4 ) NEG : (Négatif)

Syntaxe :    NEG   Destination

Elle  soustrait  l'opérande  destination  (octet  ou  mot)  de  0  le résultat est stocker dans la destination, donc avec cette opération on réalise le complément à deux d'un nombre

  Destination  <----------- 0 - Destination
Exemples :
NEC AX           ; AX = 0 - AX 
NEC AL           ; AL = 0 - AL 
NEC [SI]         ; [SI] = 0 - [SI]

Remarque :

Les indicateurs affectés par cette opération sont : AF, CF, OF, PF, SF, ZF

III-2-5 ) CMP : (Comparaison)

Syntaxe :    CMP  Destination   , Source

Elle soustrait la source de la destination , qui peut être un octet ou un mot , le résultat n'est pas mis dans la destination , en effet cette instruction touche  uniquement  les  indicateurs  pour  être  tester  avec  une  autre instruction ultérieure de saut conditionnel

Les indicateurs susceptibles d'être touché sont : AF, CF, OF, PF, SF, ZF

Donc cette instruction va nous permettre de comparer deux nombres comme le montre le tableau suivant :

III-2-6 ) AAS ) DAS: ( ASCII ) DECIMAL Adjust for Substraction )

Elle est identique à l'instruction AAA/DAA mais l'ajustement se fait en BCD pour la soustraction.

III-3 ) La multiplication :

III-3-1 ) MUL : (Multiplication pour les nombres non signés)

MUL  effectue  une  multiplication  non  signée  de  l ‘opérande  source  avec l'accumulateur :

                  Syntaxe : MUL   Source
Remarque :

Cette multiplication traite les données en tant que nombres non signés

Donc on aura :

  (AX)       <-------------   (AL) X  Source (octet)
  (AX)(DX)   <------------    (AX) X Source (mots)
En conclusion :

III-3-2 ) IMUL : (Multiplication pour les nombres signés)

MUL  effectue une multiplication signée de  l ‘opérande source avec l'accumulateur :

                  Syntaxe :    IMUL   Source
Remarque :

Cette multiplication traite les données en tant que nombres signés

III-3-3 ) AAM: (ASCII Adjust for Multiplication)

Comme  AAA et  AAS cette instruction va nous permettre de corriger le résultat d'une multiplication de deux nombres en BCD, pour corriger le résultat de l'instruction AAM divise AL par 10.

Exemple :
MOV AL , 6
MOV DL , 8
MUL DL
AAM

Si on décortique cette instruction on aura :

III-4 ) La division :

III-4-1 ) DIV : (Division des nombres non signés)

Syntaxe :   DIV  Source

Elle  effectue  une  division  non  signée  de  l'accumulateur  par  l'opérande source :

Exemples :

A/     

MOV AH,00h
MOV AL,33H
MOV DL,25H
DIV DL    ; Cela implique que AH=    et   AL =

B/     

MOV AX,500H
MOV CX,200H
DIV CX     ;Cela implique que    AX=         et   AL =

III-4-2 ) IDIV :  (Division des nombres  signés )

Syntaxe :    IDIV  Source

Elle effectue une division signée de l'accumulateur par l'opérande source :

Exemples:

A/     

MOV  AH,00h
MOV  AL,-33H
MOV DL,25H
IDIV  DL  ;   Cela implique que AH=   et   AL =

B/    

MOV AX,-500H
MOV CX,200H
IDIV  CX   ;  Cela implique que AX=   et   AL =

III-4-3 ) AAD :  (ASCII Adjust for Division )

Pour corriger le résultat elle va multiplier le contenu de AH par 10 et l'ajoute à celui de AL

Remarque :

Pour cette instruction il faut faire l'ajustement avant l'instruction de division.

III-4-4 ) CBW (convert byte to word)

Cette instruction permet de doubler la taille de l'opérande signé

  Octet ------------>  Mots
Remarque :

CBW reproduit le bit 7 (bits de signe) de AL dans AH jusqu'à remplissage de ce dernier.

Exemple :
MOV AL, +96       ; AL=0110 0000
CBW               ; AH=0000 0000 et AL=0110 0000

III-4-5 ) CWD (convert Word to Double)

Cette instruction permet de doubler la taille de l'opérande signé

  Word    -------- >    Double
Remarque :

CWD reproduit le bit 15 (bits de signe) de AX dans DX jusqu'à remplissage de ce dernier.

Exemple :
MOV  AX, +260    ; AX=0000 0001 0000 0100
CWD              ; DX=0000H, AX=0104H

IV ) Les instructions logiques ( de bits ) :

Ils  sont  divisés  en  trois  sous-groupes  comme  le  montre  le tableau suivant :

IV-1 ) Les instructions logiques :

IV-1-1 ) NOT : (Négation)

Elle réalise la complémentation à 1 d'un nombre

Syntaxe :       NOT   Destination

Exemple :
MOV AX, 500       ; AX = 0000 0101 0000 0000
NOT AX            ; AX = 1111 1010 1111 1111

IV-1-2 ) AND : ( Et logique )

Syntaxe :    AND   Destination, source

Elle permet de faire un ET logique entre la destination et la source (octet ou un mot)  le résultat est mis dans la destination

  Destination    <----------   Destination  .  source
Exemples :
MOV AX , 503H      ; AX = 0000 0101 0000 0011
AND AX , 0201H     ;       0000 0101 0000 0011
                   ;  AND  0000 0010 0000 0001
                   ;     = 0000 0000 0000 0001
AND AX,BX          ; AX = AX . BX (Et logique entre AX et BX) 
AND  AL,BH         ; AL = AL . BH (ET logique sur 8 bits)
AND AL,[SI]        ; AL = AL AND le contenu de la case mémoire
                   ; pointé  par SI
AND [DI],AL        ; ET logique entre la case mémoire pointé par
                   ; DI et  AL , le résultat est mis dans la case
                   ; mémoire pointé par DI

IV-1-3 ) OR : (OU logique )

Syntaxe :    OR     Destination, source

Elle permet de faire un OU logique entre la destination et la source (octet ou un mot)  le résultat est mis dans la destination

   Destination   <----------- Destination  +  source
Exemples :
MOV AX , 503H        ; AX = 0000 0101 0000 0011
OR AX , 0201H        ;          0000 0101 0000 0011
                     ;    OR    0000 0010 0000 0001
                     ;    =     0000 0111 0000 0011
OR AX,BX             ; AX = AX + BX ( OU logique entre AX et BX ) 
OR  AL,BH            ; AL = AL + BH ( OU logique sur 8 bits )
OR AL,[SI]           ; AL = AL OU le contenu de la case mémoire
                     ; pointé  par SI
OR [DI],AL           ; OR logique entre la case mémoire pointé par
                     ; DI et  AL, le résultat est mis dans la case
                     ; mémoire pointé par DI

IV-1-4 ) XOR : ( OU exclusif  )

Syntaxe :    XOR  Destination, source

Elle permet de faire un OU exclusif logique entre la destination et la source (octet ou un mot)  le résultat est mis dans la destination

  Destination   <------------ Destination  +  source
Exemples :
MOV AX , 503H   ; AX = 0000 0101 0000 0011
XOR AX , 0201H  ;          0000 0101 0000 0011
                ;   XOR    0000 0010 0000 0001
                ;    =     0000 0011 0000 0010
XOR AX,BX       ; AX = AX + BX (OU exclusif  entre AX et BX ) 
XOR  AL,BH      ; AL = AL + BH ( OU exclusif sur 8 bits ) 
XOR AL,[SI]     ; AL = AL OU exclusif le contenu de la case
                ; Mémoire pointé  par SI
XOR [DI],AL     ; XOR logique entre la case mémoire pointé par
                ; DI et  AL, le résultat est mis dans la case
                ; mémoire pointé par DI

IV-1-5 ) TEST :

Syntaxe :    TEST   Destination, source

Elle permet de faire un ET logique entre la destination et la source (octet ou un mot)  mais la destination ne sera pas touchée en effet cette instruction ne touche que les indicateurs.

Exemples :
MOV AX, 503H    ; AX = 0000 0101 0000 0011
TEST AX, 0201H  ;  0000 0101 0000 0011

Elle va effectuer un ET logique entre le premier nombre et le second sans toucher les deux mais elle va affecter uniquement les indicateurs (Flags)

IV-2 ) Les instructions de décalages :

SHL : décalage logique à gauche :

SHR : décalage logique à droite :

SAL : décalage arithmétique à gauche :

SAR : décalage arithmétique à gauche :

IV-3 ) Les instructions de rotations :

ROL : Rotation à gauche :

RCL : Rotation a travers la retenue à gauche :

ROR : Rotation à droite :

RCR : Rotation à travers la retenue à droite :

Syntaxe des instructions de rotation et de décalage :

ROR  destination, compteur
Exemple :
         ROR AX,1
         ROL AL,1

Si on veut faire quatre rotations de suite on a deux solutions :

ROR AL,1
ROR AL,1
ROR AL,1
ROR AL,1

Ou encore :

         MOV CL,4
         ROR AL,CL
Remarque :

Les instructions de rotations et de décalages logiques ne tiennent pas compte du bit de signe donc elles travaillent avec les nombres non signés.

Les instructions de rotations et de décalages arithmétiques préservent le bit de signe donc elles sont réservées aux nombres signés.

V ) Instructions de sauts de programme :

Elles permettent de faire des sauts dans l'exécution d'un programme (rupture de séquence)

Remarque :

Ces instructions n'affectent pas les Flags. Dans cette catégorie on trouve toutes les instructions de branchement, de boucle et d'interruption après un branchement, le tableau suivant donne ces instructions :

V-1 ) Branchement inconditionnel

V-1-1 ) CALL : notion de procédure :

La notion de procédure en assembleur correspond à celle de fonction en langage C, ou de sous-programme dans d'autres langages.

La procédure est nommée calcul. Après l'instruction B, le processeur passe à l'instruction C de la procédure, puis continue jusqu'à rencontrer RET et revient à l'instruction D.

Une procédure est une suite d'instructions effectuant une action précise, qui sont regroupées par commodité et pour éviter d'avoir à les écrire à plusieurs reprises dans le programme.

Les procédures sont repérées par l'adresse de leur première instruction, à laquelle on associe une étiquette en assembleur.

L'exécution d'une procédure est déclenchée par un programme  appelant. Une procédure peut elle-même appeler une autre procédure, et ainsi de suite.

Instructions CALL et RET

L'appel d'une procédure est effectué par l'instruction CALL.

CALL adresse_debut_procedure

L'adresse est sur 16 bits, la procédure est donc dans le même segment d'instructions.   CALL   est   une nouvelle   instruction   de   branchement inconditionnel. La fin d'une procédure est marquée par l'instruction RET :

V-1-2 ) RET :

RET ne prend pas d'argument ; le processeur passe à l'instruction placée immédiatement après le CALL.

RET est aussi une instruction de branchement : le registre IP est modifié pour revenir à la valeur qu'il avait avant l'appel par CALL. Comment le processeur retrouve-t-il cette valeur ? Le problème est compliqué par le fait que l'on peut avoir un nombre quelconque d'appels imbriqués, comme sur la figure suivante :

L'adresse de retour, utilisée par RET, est en fait sauvegardée sur la pile par l'instruction CALL. Lorsque le processeur exécute l'instruction RET, il dépile l'adresse sur la pile (comme POP), et la range dans IP.

L'instruction CALL effectue donc les opérations :

Et l'instruction RET :

Remarque 1 :

Si  la  procédure  appartient  au  même  segment  que  le  programme principal elle est dite de type NEAR sinon elle est dite de type FAR, la différence entre eux c'est que dans le premier cas le processeur doit empiler une seule valeur dans la pile c'est le registre IP mais dans le deuxième cas il faut empiler le registre IP ainsi que le registre segment CS et bien sur il les dépiler pendant le retour de la procédure.

Remarque 2 : Passage de paramètres

En général, une procédure effectue un traitement sur des données

(paramètres) qui sont fournies par le programme appelant, et produit un résultat qui est transmis à ce programme. Plusieurs stratégies peuvent être employées :

1. Passage par registre : les valeurs des paramètres sont contenues dans des registres du processeur. C'est une méthode simple, mais qui ne convient que si le nombre de paramètres est petit (il y a peu de registres).

2.  Passage  par  la  pile  :  les  valeurs  des  paramètres  sont  empilées.  La procédure lit la pile.

Exemple avec passage par registre

On va écrire une procédure (SOMME) qui calcule la somme de 2 nombres naturels de 16 bits.

Convenons que les entiers sont passés par les registres AX et BX, et que le résultat sera placé dans le registre AX.

La procédure s'écrit alors très simplement : SOMME PROC  NEAR

                         ADD AX, BX      ; AX <- AX + BX
                         RET SOMME ENDP

et son appel, par exemple pour ajouter 6 à la variable Truc :

                             MOV AX, 6
                             MOV BX, Truc
                             CALL SOMME
                             MOV Truc, AX

Exemple avec passage par la pile

Cette technique met en œuvre un nouveau registre, BP (Base Pointer), qui permet de lire des valeurs sur la pile sans les dépiler ni modifier SP. Le registre BP permet un mode d'adressage indirect spécial, de la forme :

                              MOV AX, [BP+6]

Cette instruction charge le contenu du mot mémoire d'adresse BP+6 dans

AX. Ainsi, on lira le sommet de la pile avec :

                             MOV BP, SP          ; BP pointe sur le sommet
                             MOV AX, [BP]        ; lit sans dépiler

Et le mot suivant avec :

MOV AX, [BP+2]      ; 2 car 2 octets par mot de pile.


L'appel de la procédure (SOMME2) avec passage par la pile est :

PUSH 6
PUSH Truc
CALL SOMME2

La procédure SOMME2 va lire la pile pour obtenir la valeur des paramètres. Pour cela, il faut bien comprendre quel est le contenu de la pile après le CALL :

Le sommet de la pile contient l'adresse de retour (ancienne valeur de IP

empilée par CALL). Chaque élément de la pile occupe deux octets. La procédure SOMME2 s'écrit donc :

SOMME2 PROC near             ; AX <- arg1 + arg2
MOV BP, SP                   ; adresse sommet pile
MOV AX, [BP+2]               ; charge argument 1
ADD AX, [BP+4]               ; ajoute argument 2
RET
SOMME2 ENDP

La valeur de retour est laissée dans AX.

La solution avec passage par la pile parait plus lourde sur cet exemple simple. Cependant, elle est beaucoup plus souple dans le cas général que le passage par registre. Il est très facile par exemple d'ajouter deux paramètres supplémentaires sur la pile. Une procédure bien écrite modifie le moins de registres possible. En général, l'accumulateur est utilisé pour transmettre le résultat et est donc modifié. Les autres registres utilisés par la procédure seront normalement sauvegardés sur la pile. Voici une autre version de SOMME2 qui ne modifie pas la valeur contenue par BP avant l'appel :

SOMME2 PROC near                   ; AX <- arg1 + arg2
PUSH BP                            ; sauvegarde BP
MOV BP, SP                         ; adresse sommet pile
MOV AX, [BP+4]                     ; charge argument 1
ADD AX, [BP+6]                     ; ajoute argument 2
POP BP                             ; restaure ancien BP
RET
SOMME2 ENDP

Noter que les index des arguments (BP+4 et BP+6) sont modifiés car on a ajouté une valeur au sommet de la pile.

V-1-3 ) JMP : (Saut inconditionnel)

        Syntaxe :

                        JMP cible

Si le JMP est de type NEAR alors IP = IP + Déplacement

Si le JMP est de type FAR  alors CS et IP sont remplacé par les nouvelles valeurs obtenues à partir de l'instruction.

JMP  transfert,  sans  condition,  la  commande  à  l'emplacement  de destination. L'opérande Cible peut être obtenu à partir de l'instruction elle- même (JMP direct) ou à partir de la mémoire ou à partir d'un registre indiqué par l'instruction.

V-2 saut conditionnel :

V-2-1 ) JC : (Si retenue)

Si  CF=1  alors  IP  =  IP  +  déplacement

V-2-2 ) JE/JZ :(Si égal/Si zéro)

Si  ZF=1  alors  IP  =  IP  +  déplacement

V-2-3 ) JNC :(Si pas de retenue)

Si  CF=0  alors  IP  =  IP  +  déplacement

V-2-4 ) JNE/JNZ :(Si non égal ) Non zéro)

Si  ZF=0  alors  IP  =  IP  +  déplacement

V-2-5 ) JNO :(Si pas de débordement)

Si  OF=0  alors  IP  =  IP  +  déplacement

V-2-6 ) JNP/JPO :(Si pas de parité/ Si parité impaire)

Si  PF=0  alors  IP  =  IP  +  déplacement

V-2-7 ) JNS :(Si pas de signe)

Si  SF=0  alors  IP  =  IP  +  déplacement

V-2-8 ) JO :(Si débordement)

Si  OF=0  alors  IP  =  IP  +  déplacement

V-2-9 ) JP/JPE:(Si parité ) Si parité paire)

Si  PF=1  alors  IP  =  IP  +  déplacement

V-2-10 ) JS :(Si signe (négatif))

Si  SF=1  alors  IP  =  IP  +  déplacement

V-3 ) Les instructions de boucle :

V-3-1 /LOOP : (boucle) :

Elle décrémente le contenu de CX de 1.

Si CX est différente de zéro alors IP = IP + déplacement

Si CX = 0 l'instruction suivante est exécutée.

L'exécution de l'instruction MOV BX, AX sera faite après l'exécution de la boucle 5 fois.

V-3-2 ) LOOPE ) LOOPZ : (boucle si égale ou si égale à zéro) : Le registre CX est décrémenter de 1 automatiquement

Si CX est différent de zéro et ZF=1 alors IP = IP + déplacement

V-3-3 ) LOOPNE ) LOOPNZ : (boucle si égale ou si égale à zéro) : Le registre CX est décrémenter de 1 automatiquement

Si CX est différent de zéro et ZF=0 alors IP = IP + déplacement

Exemple :

VI ) Les instructions de chaînes de caractères :

Les instructions de chaînes des caractères sont au nombre de 14 comme le montre le tableau suivant :

Elles permettent de travailler sur des blocs d'octets ou de mots allant jusqu'à 64 Koctet.

Remarque :

Ces  blocs  peuvent  être  des valeurs numériques ou alphanumériques.

VI -1 ) Les préfixes de répétitions :

VI-1-1 ) REP :

Ces instructions sont utilisées avec les instructions de chaînes de caractères pour assurer la répétition de l'instruction si on veut appliquer l'instruction sur un ensemble d'informations.

REP décrément automatiquement CX est test est ce qu'il est égal à zéro ou non. Si  CX = 0 REP s'arrêt

VI-1-2 ) REPE ) REPZ :

Pour REPE/REPZ : c'est la même chose que REP c'est-à-dire elle décrément automatiquement le registre CX mais elle peut sortir de la boucle si ZF<>0

VI-1-2 ) REPNE ) REPNZ :

Pour REPNE/REPNZ : c'est la même chose que REP c'est-à-dire elle décrément automatiquement le registre CX mais elle peut sortir de la boucle si ZF=0

VI-2/ Les instructions MOVE-STRING :

Elle  déplace  un  élément  du  segment  de  données  pointé  par

DS : SI vers le segment Extra pointé par ES : DI

Remarque :

Si l'élément à transférer est un octet on utilise : MOVB Si l'élément à transférer est un Mot on utilise : MOVW

Mais dans les deux cas on n'utilise que d'opérande.

SI et DI sont ensuite incrémentés de 1 (si DF=0) ou décrémentés de 1 (si DF=1) d'une manière automatique.

Exemple :
Donnee SEGMENT
Mess_Sour db ‘bonjour iset de nabeul'     ; message source
Donnee ENDS
Extra SEGMENT
Mes_Des db 22 dup (0)                    ; message destination
Extra ENDS
Code SEGMENT
Assume CS : Code, DS : Donnee, ES : extra
PROG PROC
MOV AX,Donnee MOV DS, AX MOV AX,Extra MOV ES, AX
LEA SI, Mess_Sour                 ; pointé le message source
LEA DI, Mess_Des                  ; pointé le message destination
MOV CX, 22                        ; nombre de caractère à transfèrer
CLD                               ; incrémentation automatique du SI et DI
REP MOVSB                         ; transfert avec le préfixe REP MOV AX, 4C00H 
                                  ; Retour au DOS
INT 21H
PROG ENDP
CODE ENDS
END PROG

VI-3/ Les instructions COMPARE-STRING :

Comparaison  de  chaîne :  elle  soustrait  l'octet  ou  mot  de destination  (pointé  par  DI)  de  l'octet  ou  mot  source  (pointé  par SI).CMPS affecte les indicateurs mais ne change pas les opérandes.

Si CMPS est utilisé avec le préfixe de répétition REPE/REPZ, elle est interprétée comme « comparer tant que la chaîne n'est pas finie (CX <>0) et que les éléments à comparer ne sont pas égaux (ZF=1)

Si CMPS est utilisé avec le préfixe de répétition REPNE/REPNZ, elle est interprétée comme « comparer tant que la chaîne n'est pas finie (CX <>0) et que les éléments à comparer ne sont pas égaux (ZF=0)

Remarque :

On ne peut pas utilisé le préfixe REP avec l'instruction CMPS car cela revient  à  comparer  uniquement  les  deux  derniers  éléments  des  deux chaînes.

Exemple :

trouver  le premier caractère différent entre les deux chaînes.

Donnee SEGMENT
Mess_1 db ‘bonjour iset de nabeul' Mess_2 db ‘bonsoir iset de nabeul'
Donnee ENDS
Code SEGMENT
Assume CS : Code, DS : Donnee
PROG PROC
MOV AX,Donnee
MOV DS, AX
LEA SI, Mess_Sour  ; pointé le message source
LEA DI, Mess_Des   ; pointé le message destination
MO V CX, 22        ; nombre de caractère àcomparer  
CLD                ; incrémentation automatique du SI et DI
REP CMPSB          ; transfert avec le préfixe 
REP JCXZ  Tito     ; les deux chaînes sont identiques 
MOV al, [SI-1]     ; on met dans AL le caractère
                   ; Différent
Tito : MOV AX, 4C00H  ; Retour au DOS INT 21H
PROG ENDP
CODE ENDS
END PROG

VI-4 ) Les instructions SCAN STRING :

                  Syntaxe :

                           SCAS chaine_destination
                           SCASB
                           SCASW

SCAS soustrait l'élément de la chaîne de destination (octet ou mot) adressé par DI dans le segment extra du contenu de AL (un octet) ou de AX  (un  mot)  et  agit  sur  les  indicateurs.  Ni  la  chaîne  destination  ni l'accumulateur ne change de valeur.

Exemple :

recherche de la lettre ‘a' dans une chaîne. EXTRA SEGMENT

Mess_Des db ‘bonjour iset de nabeul' EXTRA ENDS
Code SEGMENT
Assume CS : Code, ES : EXTRA
PROG PROC MOV AX, EXTRA MOV ES, AX
LEA DI, Mess_Des                  ; pointé le message destination
MOV CX, 22                        ; nombre de caractère à comparer  
CLD                               ; incrémentation automatique du DI  
MOV AL,'a'
REPNZ SCASB                       ; transfert avec le préfixe REP JCXZ 
Tito  ; les deux chaînes sont identiques 
Call oui_le_a_existe          ; on met dans AL le caractère
; Différent
Tito : MOV AX, 4C00H              ; Retour au DOS 
INT 21H
PROG ENDP
CODE ENDS
END PROG

VI-5 ) Les instructions LOAD STRING (LODS) et STORE STRING (STOS) :

VI-4-1 ) LODS :

         Syntaxe :

LODS chaine_source
LODSB
LODSW

LODS transfert l'élément de chaîne (octet ou mot) adressé par SI au registre AL ou AX et remet à jour SI pour qu'il pointe vers l'élément suivant de la chaîne.

VI-4-2 ) STOS :

         Syntaxe :

STOS chaine_destination
STOSB
STOSW

STOS transfert un octet ou un mot du registre AL ou AX vers l'élément de chaîne adressé par DI et modifie DI pour qu'il pointe vers l'emplacement suivant de la chaîne.

Exemple :

transfert d'une chaîne source vers une chaîne destination en utilisant LODS et STOS.

Donnee SEGMENT
Mess_Sour db ‘bonjour iset de nabeul'     ; message source
Donnee ENDS
Extra SEGMENT
Mes_Des db 22 dup (0)                     ; message destination
Extra ENDS
Code SEGMENT
Assume CS : Code, DS : Donnee, ES : extra
PROG PROC
MOV AX,Donnee 
MOV DS, AX 
MOV AX,Extra 
MOV ES, AX
LEA SI, Mess_Sour                 ; pointé le message source
LEA DI, Mess_Des                  ; pointé le message destination
MOV CX, 22                        ; nombre de caractère à transfèrer
CLD                               ; incrémentation automatique du SI et DI
DEBUT :     LODSB                 ; transfert avec le préfixe REP STOSB
LOOP DEBUT
MOV AX, 4C00H                     ; Retour au DOS INT 21H
PROG ENDP
CODE ENDS
END PROG

VII ) Les instructions de commande du processeur :

Ces instructions agissent sur le processeur et ses indicateurs (Flags) ils sont en nombre de 12 comme le montre le tableau suivant

VII-1 ) Indicateurs :

VII-1-1/ STD :

Met CF à 1 ; les registres d'indexation SI et/ou DI sont alors automatiquement décrémenter par les instructions de chaîne de caractère.

VII-1-2 ) STI :

Met IF à 1, permettant ainsi au CPU de reconnaître des demandes   d'interruption   masquables   apparaissant   sur   la   ligne d'entrée INTR.

VII-2 ) Synchronisation :

VII-2-1 ) HALT :

Maintient le processeur dans un état d'attente d'un RESET ou  d'une  interruption  externe  non  masquable  ou  masquable  (avec IF=1).

VII-2-2 ) WAIT :

Met le CPU en état d'attente tant que sa ligne de TEST n'est pas active. En effet toutes les cinq périodes d'horloge le CPU vérifie est ce que cette entrée est active ou non, si elle est active le processus exécute l'instruction suivante à WAIT.

VII-2-3 ) ESC :

L'instruction Escape fournit un mécanisme par lequel des coprocesseurs peuvent recevoir leurs instructions à partir de la suite d'instructions du 8086.

VII-2-4 ) LOCK :

Elle utilise dans les systèmes Multiprocesseur en effet elle permet le verrouillage du bus vis-à-vis des autres processeurs.

VII-3 Sans opération :

VII-3-1 ) NOP (No operation) :

Le CPU ne fait rien on peut s'en servir pour créer des temporisations.

Exemple :

Tempo : MOV CX, 7FFFH            ; Effectuer une temporisation
Temp1: PUSH CX                       ; avec deux boucles imbriqués
MOV CX,7FFFH
Temp2: NOP NOP NOP NOP
LOOP Temp2
POP CX
LOOP Temp1
RET

instructions microprocesseur 8086 8088 programmation formation cours assembleur

Révisé le :11-11-2017 www.technologuepro.com Facebook Twitter RSS