Centre universitaire de BBA Département d’électronique

Jeu d’instructions
Du Microprocesseur
8086

Braham Chaouche Yacine Fethallah

Informatique Industrielle
 Automate qui exécute une suite d’actions élémentaires en suivant des règles précises qui lui sont dictées et tel que l’ensemble
des ces actions aboutisse à la résolution d’un problème donné

Introduction :
Définition microprocesseur d’un ordinateur :
Automate qui exécute une suite d’actions élémentaires en suivant des règles précises qui lui sont dictées et
tel que l’ensemble des ces actions aboutisse à la résolution d’un problème donné.
L’automate exécute un programme.
Programme :
Suite précises d’I qu’une machine est capable d’exécuté en suivant un ordre déterminé, à chaque instruction
correspondant une instruction particulière.
Son exécution permet d’obtenir des données résultats à partir de données de départ.
Données départ MACHINE Données résultat
↑
PGM
OU

{Pré condition (données)} PGM {post conditions (données)}

⇒ Un pgm directement exécutable est une suite d’I machine ∊ à une certaine jeu d’I et qu’un agent peut lire
et exécuter dans un ordre précis.
Dans un pgm en langage machine une erreur peut très vite se produire et il est assez difficile de la corriger
du fait que le pgm est plutôt illisible, donc on va introduire un nouveau langage symbolique pour faciliter la
rédaction de pgm, il faudra donc une phase supplémentaire de traduction.
Pgm-source -  ORDINATEUR - pgm-objet
(En lg symb.) (En lg mach.)
↑
PGM assembleur
(Traducteur=compilateur) =Phase de compilation

Plus un langage est dit évolué (de haut niveau) plus il est proche de notre façon de penser et plus il est
Loing du langage machine (de bas niveau) .Les instructions machines ne manipulent que des bytes ou des
mots.
Les registres :
Petites zones mémoires pour mémoriser des infos. à fin d’y accéder plus rapidement que si on allait les
rechercher en mc
Les registres généraux :
AX, BX, CX et DX sont à usage général et servent à stocker temporairement une info. De 16bits.
Chacun de ces registres est divisible en deux registres de 8bits une partie haute (AH) et une partie base (AL)
AX (accumulateur) : instructions d’I/O et certaines op. Arithm.
BX (registre de base) : peut être utilisé comme registre d’adressage lors de l’adressage direct à la mémoire.
CX (compteur) : compteur de boucles
DX : contient les adresses des ports pour les instructions I/O
Les registres d’index et pointeurs :
SI et DI peuvent être utilisés comme reg. Gén. De données Mais le plus souvent sont utilisés avec les
instructions spécialisées de manipulation des chaînes de caractères et aussi comme reg. D’adressage
(indexé).
SP et BP accèdent aux données de la pile (SS : SP = sommet de la pile et BP accède à des données dans la
pile)
IP pointer d’instruction CS : IP = l’adresse de l’instruction suivante
Les registres de segments :
CS, DS, ES et SS font partie du BIU il les utilise pour calculer l’ad. Phys.
Les instructions peuvent être soit codées sur 1,2,3,4,5,6 octets et présentées sous la
forme suivante :
Mnémonique Op1, Opération réalisée

Types possibles pour le(s) Code Code Indicate

opérande(s) 0 1 urs

Op1, Op2 : désignent les deux premiers opérandes

Code0 : désigne le premier octet du code de l’instruction
Code1 : désigne la suite du code de l’instruction

Chaque indicateur est représenté par une lettre suivant la correspondance suivant :

O : dépassement de capacité (overflow)

S : signe
Z : résultat nul (zero)
A : demi-retenue (half carry)
P : parité
C : retenue (carry)

Les abréviations suivantes sont utilisées pour le codage des instructions :

d : indique la destination (si d=1, destination = reg, sinon reg/mem)

w : dimension des opérandes (si w=0, opérandes 8 bits, sinon 16 bits)
acc : désigne le registre accumulateur (AX ou AL)
reg : désigne le champ registre (cf table)
r_s : désigne un registre de segment (cf table)
r/m : désigne le champ reg/mem (cf table)
mod : permet d’interpréter le champ r/m (cf table)
mem : désigne une adresse en mémoire
Adr : désigne une adresse (8/16/32 bits)
Imm : désigne une valeur immédiate (8/16 bits)
L :désigne low
H :désigne high

Les instructions entières utilisent des opérandes codées sur 8 et 16 bits :

Dimensions des
opérandes
BYTE 8 bits 1 octet
WORD 16 bits 2
octets

En cas d’incertitude non résolue par les opérandes, les mots clés BYTE PTR ou
WORD PTR devront être utilisés.

Concernant l’ordre de rangement en mémoire des nombres codés sur plus d’un octet,
les processeurs Intel sont de type « petit-boutien » : L’octet contenant les bits
les moins significatifs est rangé à l’adresse la plus basse.

Mnemonic et description Codes des instructions Flags

Les instructions de transfert
r/m <- reg 1000 100 mod reg r/m
w
MOV = Move reg <- r/m mod reg r/m
1000 101
r/m <- imm mod 000 r/m imm(8/1
w
6)
reg <- imm imm(8/16) ------
Déplacement d’un 1100 011
acc <- mem w adr(L)
octet ou d’un mot
adr(H)
mem <- acc 1011 w reg adr(L)
adr(H)
r_s <- r/m 1010 000 mod 0 r_s r/m
w
r/m <- r_s mod 0 r_s r/m
1010 001
w

1000 1110

1000 1100

PUSH = Push r/m 1111 1111 mod 110 r/m ------

reg 0101 0 reg

Ecriture d’un mot au
sommet de la pile r_s 000 r_s 110

PUSHF = Push Flags 1001 1100 ------

Sauvegarde des flags

sur la pile
POP = Pop r/m 1000 1111 mod 000 r/m ------

Lecture d’un mot au reg (forme 0101 1reg

réduite)
sommet de la pile 000r_s111
r_s

POPF = Pop Flags 1001 1101 OSZAPC

Restauration des flags

à partir de la pile

XCHG = Exchange r/m <-> reg 1000 011w mod reg r/m ------

reg <-> acc 1001 0reg

Echange d’octets ou de
mots

LEA = Load EA to reg <- adr de 1000 1101 mod reg r/m ------
mem
Register Chargement
d’une adresse effective mod = 11
interdit

------

LDS = Load Pointer reg <- mem 1100 0101 mod reg r/m

to DS mod = 11
interdit
Chargement d’un
pointeur utilisant DS

LES = Load Pointer reg <- mem 1100 0100 mod reg r/m ------

to ES mod = 11
interdit
Chargement d’un
pointeur utilisant ES

STC

Met le flag de retenue CF <- 1 1111 1001 -----C

à1

CLC CF <- 0 1111 1000 -----C

Efface le flag de
retenue

CMC CF <- not CF 1111 0101 -----C

Inverse l’état du flag

de retenue

Les instructions arithmétiques

reg <- reg+reg 0000 00dw mod reg r/m

mem <- 0000 000w mod reg r/m

ADD = Add
mem+reg
0000 001w mod reg r/m imm(8/1 OSZAPC
Addition d’octets ou reg <- reg+mem 6)
de mots 1000 00sw mod 000 r/m
r/m <- r/m+imm
0000 010w imm(8/16)
acc <- acc+imm

reg <- 0000 10dw mod reg r/m

reg+reg+CF
0001 000w mod reg r/m
ADC = Add with
mem <-
Carry mem+reg+CF
0001 001w mod reg r/m OSZAPC

Addition d’octets ou 1000 00sw mod 010 r/m

reg <-
de mots avec reg+mem+CF 0001 010w imm(8/16)
retenue r/m <-
r/m+imm+CF

acc <-
acc+imm+CF

INC = Increment r/m 1111 111w mod 000 r/m OSZAP-

reg 0100 0 reg

Incrémentation de 1
d’un octet ou d’un
mot

SUB = Subtract reg <- reg-reg 0010 10dw mod reg r/m

mem <- mem- 0010 100w mod reg r/m

Soustraction d’octets
reg
ou de mots 0010 101w mod reg r/m OSZAPC
reg <- reg-mem
1000 00sw mod 101 r/m
r/m <- r/m-imm
0010 110w imm(8/16)
 acc <- acc-imm

reg <- reg- 0001 10dw mod reg r/m

(reg+CF)
0001 100w mod reg r/m
SSB= Subtract
mem <- mem-
with Borrow (reg+CF)
0001 101w mod reg r/m OSZAPC

Soustraction d’octets 1000 00sw mod 011 r/m

reg <- reg-
ou de mots avec (mem+CF) 0001 110w imm(8/16)
retenue r/m <- r/m-
(imm+CF)

acc <- acc-

(imm+CF)

DEC = Decrement r/m 1111 111w mod 001 r/m

reg (forme 0100 1reg OSZAP-

Décrémentation de 1
réduite)
d’un octet ou d’un
mot

NEG = Change
sign 1111 011w mod 011 r/m OSZAPC

Complémentation à
2 d’un octet ou d’un
mot (changement de
signe)

CBW=Convert Byte AL -> AX 1001 1000 ------

toWord

Conversion d’octet
en mot

CWD = Convert
Word to Double AX -> DX-AX 1001 1001 ------
Word

Conversion de mot
en double mot
CMP = Compare reg-reg 0011 10dw mod reg r/m

mem-reg 0011 100w mod reg r/m

Comparaison
d’octets ou de mots reg-mem 0011 101w mod reg r/m OSZAPC

r/m-imm 1000 00sw mod 111 r/m

acc-imm 0011 110w imm(8/16)

AAA = ASCII 00110111

Adjust for Add ------

Ajustement ASCII de
l’addition

DAS = Decimal
Adjust for 00101111 ------
Subtract

Ajustement décimal
de la soustraction

Les multiplications et les divisions

MUL = Multiply
(Unsigned) Reg 1111 011w mod 1 0 0 r/m O----C

Multiplication non
signée d’octets ou
de mots

IMUL = Integer Reg 1111 011w mod 1 0 1 r/m O----C

Multiply (Signed)
Multiplication
signée d’octets ou
de mots
DIV = Divide
(Unsigned) Reg 1111 011w mod 1 1 0 r/m ------

Division non signée

d’octets ou de mots

IDIV = Integer
Divide (Signed) Reg 1111 011w mod 1 1 1 r/m ------

Division signée
d’octets ou de mots

Les instructions de décalages

SHL/SAL = Shift
Logical/Arithmetic r/m << 1,CL 1101 00vw mod 100 r/m OSZ?PC
Left

Décalage à gauche
arithmétique ou
logique (octet ou
mot)

SHR = Shift
Logical Right r/m >> 1,CL 1101 00vw mod 101 r/m OSZ?PC
Décalage logique à
droite d’un octet ou
d’un mot

SAR = Shift
Arithmetic Right r/m >> 1,CL 1101 00vw mod 111 r/m OSZ?PC

Décalage
arithmétique à
droite d’un octet ou
d’un mot

Les instructions de rotation

ROL = Rotate Left

Rotation à gauche r/m 1,CL 1101 00vw mod 000 r/m O----C
d’un octet ou d’un
mot)
ROR = Rotate
Right r/m 1,CL 1101 00vw mod 001 r/m O----C

Rotation à droite
d’un octet ou d’un
mot

RCL = Rotate
Through Carry r/m 1,CL 1101 00vw mod 010 r/m O----C
Flag Left

Rotation à gauche
incluant CF (octet
ou mot)

RCR = Rotate
Through Carry r/m 1,CL 1101 00vw mod 011 r/m O----C
Right

Rotation à droite
incluant CF (octet
ou mot)

r_s (registre segment)

00 10 1
1
ES SS D
S

Les instructions logiques

reg <- reg AND 0010 00dw mod reg r/m

reg
0010 000w mod reg r/m OSZ?PC
AND = And
mem <- mem
0010 001w mod reg r/m
ET logique de deux AND reg
octets ou de deux 1000 000w mod 100 r/m
reg <- reg AND
mots mem 0010 010w imm(8/16)
r/m <- r/m AND
imm

acc <- acc AND

imm
TEST = And r/m AND reg 1000 010w mod reg r/m

Function to Flags, r/m AND imm 1111 011w mod reg r/m OSZ-PC
No Result
acc AND imm 1010 100w imm(8/16)
Comparaison, à
l’aide d’un ET,
d’octets ou de mots

reg <- reg OR 0000 10dw mod reg r/m

reg
0000 100w mod reg r/m
OR = Or
mem <- mem
0000 101w mod reg r/m OSZ-PC
OU logique de deux OR reg
octets ou de deux 1000 000w mod 001 r/m
reg <- reg OR
mots mem 0000 110w imm(8/16)
r/m <- r/m OR
imm

acc <- acc OR

imm

XOR = Exclusive reg <- reg XOR 0011 00dw mod reg r/m
reg
or 0011 000w mod 110 r/m
mem <- mem
OU exclusif logique XOR reg 0011 001w imm(8/16) OSZ-PC
de deux octets ou 1000 000w mod reg r/m
reg <- reg XOR
de deux mots
mem 0011 010w mod reg r/m
r/m <- r/m XOR
imm

acc <- acc XOR

imm

NOT = Invert
1111 011w mod 010 r/m ------
Complément à 1
d’un octet ou d’un
mot

Les sauts inconditionnels

JMP = Adr(8) 1110 1011 dépl(8)

Unconditional Adr(16 1110 1001 dépl(16) ------
Jump r/m 1111 1111 mod 100 r/m

Saut inconditionnel Adr(32)(far) 1110 1010 Adr(32)

r/m (far) 1111 1111 mod 101 r/m

Les appels et retours de sous-programmes

Adr(16) 1110 1000 dépl(16)

r/m 1111 1111 mod 010 r/m ------

CALL = Call
Adr(32) 1001 1010 Adr(32)
Appel de procédure
r/m 1111 1111 mod 011 r/m

RET = Return (intraseg.) 1100 0011

from CALL (intraseg.) 1100 0010 imm(16) ------

imm16
Retour d’une 1100 1011 imm(16)
procédure (interseg.)
1100 1010
(interseg.)
imm16

INT = Interrupt imm(8) 1100 1101 imm(8) ------

Interruption
logicielle

IRET = Interrupt 1100 1111 ------

Return

Retour d’une
interruption

Les sauts conditionnels et branchements

instruction nom condition

JO Jump if Overflow saut si OF = 1 01110000 déplacem ------

ent
Adr

JNO Jump if Not Overflow saut si OF = 0 01110001 déplacem ------

ent
Adr
JC/JB/JNAE Jump if Carry saut si CF = 1 01110010 déplacem ------
ent
Adr

JNC/JNB/JAE Jump if Not Carry saut si CF = 0 01110011 déplacem ------

ent
Adr

JE/JZ Jump if Zero / Equal saut si ZF = 1 01110100 déplacem ------

ent
Adr

JNE/JNZ Jump if Not Zero/Not saut si ZF = 0 01110101 déplacem ------

Equal ent
Adr

JS Jump if Sign saut si SF = 1 01111000 déplacem ------

ent
Adr

JNS Jump if Not Sign saut si SF = 0 01111001 déplacem ------

ent
Adr

JP/JPE Jump if Parity saut si PF = 1 01111010 déplacem ------

ent
Adr

JNP/JPO Jump if Not Parity saut si PF = 0 01111011 déplacem ------

ent
Adr

LOOP Adr Loop CX Times CX<-CX-1, si 11100010 déplacem ------

CX≠0 ent

LOOPZ/LOOPE Loop While CX<-CX-1, si 11100001 déplacem ------

Adr Zero/Equal CX≠0 ou ZF=1 ent
LOOPNZ/NE Adr Loop While Not CX<-CX-1, si déplacem ------
Zero/Equal CX≠0 ou ZF=0 ent