Exposé Instruction Ce Mémento Indique L

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 ↑ PGM OU

Données résultat

{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, Types possibles pour le(s) opérande(s)

Opération réalisée Code 0

Code 1

Indicate 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 Les instructions de transfert r/m <- reg

MOV = Move

reg <- r/m r/m <- imm

Déplacement d’un octet ou d’un mot

reg <- imm

1000 100 w 1000 101 w

acc <- mem

1100 011 w

mem <- acc

1011 w reg

r_s <- r/m r/m <- r_s

1010 000 w 1010 001 w

Flags

mod reg r/m mod reg r/m mod 000 r/m imm(8/16)

imm(8/1 6)

------

adr(L) adr(L) mod 0 r_s r/m

adr(H) adr(H)

mod 0 r_s r/m

1000 1110 1000 1100

PUSH = Push

r/m

1111 1111

Ecriture d’un mot au sommet de la pile

reg

0101 0 reg

r_s

000 r_s 110

PUSHF = Push Flags Sauvegarde des flags sur la pile

1001 1100

mod 110 r/m

------

------

POP = Pop

r/m

1000 1111

Lecture d’un mot au sommet de la pile

reg (forme réduite)

0101 1reg

mod 000 r/m

------

000r_s111

r_s

1001 1101

POPF = Pop Flags

OSZAPC

Restauration des flags à partir de la pile

XCHG = Exchange

r/m <-> reg

1000 011w

Echange d’octets ou de mots

reg <-> acc

1001 0reg

LEA = Load EA to Register Chargement d’une adresse effective

reg <- adr de mem

1000 1101

mod reg r/m

------

mod reg r/m

------

mod = 11 interdit ------

LDS = Load Pointer to DS Chargement d’un pointeur utilisant DS

LES = Load Pointer to ES Chargement d’un pointeur utilisant ES

reg <- mem

1100 0101

mod reg r/m

1100 0100

mod reg r/m

mod = 11 interdit

reg <- mem

------

mod = 11 interdit

STC Met le flag de retenue à1

CF <- 1

1111 1001

-----C

CLC

CF <- 0

1111 1000

-----C

Efface le flag de

retenue

CF <- not CF

CMC

1111 0101

-----C

Inverse l’état du flag de retenue Les instructions arithmétiques reg <- reg+reg

0000 00dw

mod reg r/m

ADD = Add

mem <mem+reg

0000 000w

mod reg r/m

Addition d’octets ou de mots

0000 001w

mod reg r/m

reg <- reg+mem

1000 00sw

mod 000 r/m

0000 010w

imm(8/16)

0000 10dw

mod reg r/m

0001 000w

mod reg r/m

0001 001w

mod reg r/m

1000 00sw

mod 010 r/m

0001 010w

imm(8/16)

mod 000 r/m

r/m <- r/m+imm

imm(8/1 6)

OSZAPC

acc <- acc+imm

reg
ADC = Add with Carry Addition d’octets ou de mots avec retenue

mem <mem+reg+CF reg
OSZAPC

r/m
INC = Increment

r/m

1111 111w

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

reg

0100 0 reg

SUB = Subtract

reg <- reg-reg

0010 10dw

mod reg r/m

Soustraction d’octets ou de mots

mem <- memreg

0010 100w

mod reg r/m

0010 101w

mod reg r/m

1000 00sw

mod 101 r/m

0010 110w

imm(8/16)

reg <- reg-mem r/m <- r/m-imm

OSZAP-

OSZAPC

acc <- acc-imm

reg <- reg(reg+CF)

SSB= Subtract with Borrow Soustraction d’octets ou de mots avec retenue

mem <- mem(reg+CF) reg <- reg(mem+CF)

0001 10dw

mod reg r/m

0001 100w

mod reg r/m

0001 101w

mod reg r/m

1000 00sw

mod 011 r/m

0001 110w

imm(8/16)

mod 001 r/m

OSZAPC

r/m <- r/m(imm+CF) acc <- acc(imm+CF)

DEC = Decrement

r/m

1111 111w

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

reg (forme réduite)

0100 1reg

NEG = Change sign

1111 011w

OSZAP-

mod 011 r/m

OSZAPC

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

CBW=Convert Byte AL - rel="nofollow"> AX toWord

1001 1000

------

1001 1001

------

Conversion d’octet en mot

CWD = Convert Word to Double Word Conversion de mot en double mot

AX -> DX-AX

CMP = Compare

reg-reg

0011 10dw

mod reg r/m

Comparaison d’octets ou de mots

mem-reg

0011 100w

mod reg r/m

reg-mem

0011 101w

mod reg r/m

r/m-imm

1000 00sw

mod 111 r/m

acc-imm

0011 110w

imm(8/16)

OSZAPC

00110111

AAA = ASCII Adjust for Add

------

Ajustement ASCII de l’addition

DAS = Decimal Adjust for Subtract

00101111

------

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

Reg

1111 011w

mod 1 0 1 r/m

O----C

Multiplication non signée d’octets ou de mots

IMUL = Integer Multiply (Signed) Multiplication signée d’octets ou de mots

DIV = Divide (Unsigned)

Reg

1111 011w

mod 1 1 0 r/m

------

Reg

1111 011w

mod 1 1 1 r/m

------

Division non signée d’octets ou de mots

IDIV = Integer Divide (Signed) Division signée d’octets ou de mots

Les instructions de décalages

SHL/SAL = Shift Logical/Arithmetic Left

r/m << 1,CL

1101 00vw

mod 100 r/m

OSZ?PC

r/m >> 1,CL

1101 00vw

mod 101 r/m

OSZ?PC

r/m >> 1,CL

1101 00vw

mod 111 r/m

OSZ?PC

Décalage à gauche arithmétique ou logique (octet ou mot) SHR = Shift Logical Right Décalage logique à droite d’un octet ou d’un mot SAR = Shift Arithmetic Right Décalage arithmétique à droite d’un octet ou d’un mot Les instructions de rotation

ROL = Rotate Left Rotation à gauche d’un octet ou d’un mot)

r/m 1,CL

1101 00vw

mod 000 r/m

O----C

ROR = Rotate Right

r/m 1,CL

1101 00vw

mod 001 r/m

O----C

r/m 1,CL

1101 00vw

mod 010 r/m

O----C

r/m 1,CL

1101 00vw

mod 011 r/m

O----C

Rotation à droite d’un octet ou d’un mot RCL = Rotate Through Carry Flag Left Rotation à gauche incluant CF (octet ou mot) RCR = Rotate Through Carry Right Rotation à droite incluant CF (octet ou mot)

r_s (registre segment) 00

10

ES

SS

1 1 D S

Les instructions logiques

reg <- reg AND reg

AND = And ET logique de deux octets ou de deux mots

mem <- mem AND reg reg <- reg AND mem r/m <- r/m AND imm acc <- acc AND imm

0010 00dw

mod reg r/m

0010 000w

mod reg r/m

0010 001w

mod reg r/m

1000 000w

mod 100 r/m

0010 010w

imm(8/16)

OSZ?PC

TEST = And Function to Flags, No Result

r/m AND reg

1000 010w

mod reg r/m

r/m AND imm

1111 011w

mod reg r/m

acc AND imm

1010 100w

imm(8/16)

reg <- reg OR reg

0000 10dw

mod reg r/m

0000 100w

mod reg r/m

0000 101w

mod reg r/m

1000 000w

mod 001 r/m

0000 110w

imm(8/16)

0011 00dw

mod reg r/m

0011 000w

mod 110 r/m

0011 001w

imm(8/16)

1000 000w

mod reg r/m

0011 010w

mod reg r/m

1111 011w

mod 010 r/m

OSZ-PC

Comparaison, à l’aide d’un ET, d’octets ou de mots

OR = Or OU logique de deux octets ou de deux mots

mem <- mem OR reg reg <- reg OR mem

OSZ-PC

r/m <- r/m OR imm acc <- acc OR imm

XOR = Exclusive or OU exclusif logique de deux octets ou de deux mots

reg <- reg XOR reg mem <- mem XOR reg reg <- reg XOR mem

OSZ-PC

r/m <- r/m XOR imm acc <- acc XOR imm

NOT = Invert Complément à 1 d’un octet ou d’un mot

------

Les sauts inconditionnels

JMP = Unconditional

Adr(8)

1110 1011

dépl(8)

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

CALL = Call Appel de procédure

RET = Return from CALL Retour d’une procédure

Adr(16)

1110 1000

dépl(16)

r/m

1111 1111

mod 010 r/m

Adr(32)

1001 1010

Adr(32)

r/m

1111 1111

mod 011 r/m

(intraseg.)

1100 0011

(intraseg.) imm16

1100 0010

imm(16)

1100 1011

imm(16)

(interseg.)

------

------

1100 1010

(interseg.) imm16

INT = Interrupt Interruption logicielle

imm(8)

1100 1101

imm(8)

------

1100 1111

IRET = Interrupt Return

------

Retour d’une interruption

Les sauts conditionnels et branchements instruction

nom

condition

JO Adr

Jump if Overflow

saut si OF = 1

01110000

déplacem ent

------

JNO Adr

Jump if Not Overflow

saut si OF = 0

01110001

déplacem ent

------

Jump if Carry

saut si CF = 1

01110010

déplacem ent

------

Jump if Not Carry

saut si CF = 0

01110011

déplacem ent

------

JE/JZ Adr

Jump if Zero / Equal

saut si ZF = 1

01110100

déplacem ent

------

JNE/JNZ Adr

Jump if Not Zero/Not Equal

saut si ZF = 0

01110101

déplacem ent

------

JS Adr

Jump if Sign

saut si SF = 1

01111000

déplacem ent

------

JNS Adr

Jump if Not Sign

saut si SF = 0

01111001

déplacem ent

------

Jump if Parity

saut si PF = 1

01111010

déplacem ent

------

Jump if Not Parity

saut si PF = 0

01111011

déplacem ent

------

Loop CX Times

CX<-CX-1, si CX≠0

11100010

déplacem ent

------

Loop While Zero/Equal

CX<-CX-1, si CX≠0 ou ZF=1

11100001

déplacem ent

------

JC/JB/JNAE Adr

JNC/JNB/JAE Adr

JP/JPE Adr

JNP/JPO Adr

LOOP Adr

LOOPZ/LOOPE Adr

LOOPNZ/NE Adr

Loop While Not Zero/Equal

CX<-CX-1, si CX≠0 ou ZF=0

déplacem ent

------