Architecture interne du

microprocesseur 8086.

 Bus d'adresse:
Le 8086 utilise un bus d'adresse de 20 bits, ce qui lui permet d'atteindre
220 = 1M cases mémoire de 1 octet chacune. Les 16 bits de poids faible du bus
d'adresse sont multiplexés avec les 16 bits du bus de données, alors que les 4 bits
de poids fort sont eux aussi multiplexés avec 4 bits de statut.

 Organisation de l'espace adressable.

numéro de segment (16 bits) 0000

+ déplacement (16 bits)

= adresse physique 20 bits

Jelassi Khaled Microprocesseurs 1

 Mode d’adressage

 Mode d’adressage
• Les instructions peuvent avoir 0, 1, ou 2 opérandes.
Exemples :

Instructions sans opérande: NOP, STI, CLI, PUSHF, CBW...;

Instructions avec une seule opérande: INC, DEC, NEG, NOT ....;
Instructions avec deux opérandes: CMP, ADD, MOV, LEA, XCHG, AND ......

 Une opérande peut se trouver dans un registre du 8086, dans un octet,

dans un mot 16 bits ou dans un double mot 32 bits.
 Les opérations peuvent avoir lieu:

 entre un registre et un autre registre,

 entre un registre et un octet ou un mot en mémoire mais pas entre 2 octets ou
2 mots en mémoire (il faut passer dans ce cas par un registre). Toutefois les
instructions de mouvement de chaînes d'octets effectuent "directement" le
transfert de mémoire à mémoire (octet par octet ou mot par mot), l'adressage
se faisant par les registres DS:SI et ES:DI.

Jelassi Khaled Microprocesseurs 2

 Mode d’adressage
Les instructions de transfert

 adressage registre à registre.

Exemple: MOV AX, BX ; opérandes 16 bit

ADD CH, DL ; opérandes 8 bits

 adressage immédiat.
Exemples: MOV AX, 0A1EBH ; AX:= valeur hexa A1EB
ADD CL, 25 ; CL:= CL + 25
OR AH,11000000 ; forcer les 2 bits de fort poids de AH à 1
 adressage direct.

Exemples: MOV BX,Total

MOV DX,ES:Nom

 adressage indirect (ou basé).

Exemples: MOV AX,[BX]

MOV AX,[BP]

 adressage indexé.

Exemple: MOV AX,Tab[SI]

 adressage indirect indexé (ou basé indexé).

Exemples: MOV AX,[BX][SI] ; relatif a DS

MOV AX,[BP][SI] ;Relatif a SS

 adressage basé indexé avec déplacement.

Exemple: MOV AX,Compte[BX][SI]

Jelassi Khaled Microprocesseurs 3

 Les Principales Instructions de
l’assembleur

 L’instruction LEA

Exemples: LEA BX,Tableau   ;chargement de l’adresse de Tableau

LEA BX,Tableau[SI]

 L'instruction XCHG.
Exemple: XCHG AX,Somme ;échange des contenus de AX et de Somme

 Les instructions PUSH et POP

Exemple: PUSH SI ;empile le contenu de SI

Les instructions arithmétiques

Les instructions d'addition ADD et ADC.

Exemples:

ADD AX,BX ;AX reçoit AX + BX

ADD AX,0F00H ;ces 2 instructions additionnent la
ADC DX,0 ;valeur immédiate 0F00H à la paire de
;registres DX:AX (32 bits).
Les instructions de soustraction SUB et SBB.

SUB AX,DX ;AX reçoit AX-DX

SBB SI,100 ;SI reçoit SI-100 - Carry

Jelassi Khaled Microprocesseurs 4

 Les Principales Instructions de
l’assembleur

 Les instructions de multiplication: MUL et IMUL

Exemples:
MUL CL ; AX:=AL * CL résultat sur 16 bits
IMUL CX ; DX:AX:= AX * CX résultat sur 32 bits non signe

 Les instructions de division: DIV et IDIV

Exemples:
IDIV BX ;DX:AX est divisé par BX, le reste est dans DX et le quotient dans AX
DIV BL ;AX est divisé par BL, le reste est dans AH, le quotient dans AL.

Les instructions de décalage et de rotation

 Les instructions de décalage gauche :SHL Opérande,Nombre

Opérande: Opérande = registre / case mémoire

Nombre: Nombre = soit la valeur 1, soit la valeur contenue dans CL

 Les instructions de décalage droite :SHR Opérande,Nombre

Jelassi Khaled Microprocesseurs 5

 Les principales instructions de
l’assembleur
 Les instructions de rotation gauche :ROL Opérande,Nombre

 Les instructions de rotation gauche :ROR Opérande,Nombre

 Les instructions de rotation gauche avec retenu :RCL Opérande,Nombre

 Les instructions de rotation droite avec retenu :RCR Opérande,Nombre

 Les instructions logiques AND, OR et XOR

Syntaxe: AND Destination,Source

OR Destination,Source
XOR Destination,Source
Destination = registre/case mémoire
Source = registre/valeur immédiate/case mémoire à condition que
Destination ne soit pas une case mémoire.
Jelassi Khaled Microprocesseurs 6
 Les principales instructions de
l’assembleur

 Les instructions logiques AND, OR et XOR

Exemples:
• AND AX,0FFF0H ;met à 0 les 4 bits de faible poids de AX
• OR AL,1 ;met à 1 le bit de faible poids de AL
• AND AX,Masque ;fait un ET logique entre le contenu de AX
;et celui de Masque, le résultat est dans AX
• XOR AX,-1 ;fait le complément à 1 de AX
• TEST BX,0FFFE ; fait un ET logique entre le contenu de BX
;et 0FFFE sans modifier BX. Permet de
;tester le bit 1 de BX

0011 0011 0011

OR 0 1 0 1 AND 0 1 0 1 XOR 0101

0111 0001 0110

Les instructions de comparaison

Syntaxe: CMP Destination,Source
TEST Destination,Source
Destination = registre / case mémoire
Source = registre / case mémoire / valeur

Exemples:

• CMP AL,CL ; compare AL à CL

• CMP AL,0 ; compare AL à 0
• TEST AL,AH ; ET logique entre AL et AH
Remarque: TEST laisse les opérandes du ET logique inchangées; les indicateurs sont
positionnés en fonction du résultat du ET logique.
Jelassi Khaled Microprocesseurs 7
 Les principales instructions de
l’assembleur

Les instructions de saut.

 Saut inconditionnel:
Exemple:
JMP Cas1 ;saut direct
JMP [BX] ;saut indirect à l'adresse contenue dans BX

 Saut conditionnel:

Les instructions de saut testant un flag.

JC / JNC Jump if Carry / not Carry

JS / JNS Jump if Sign/ not Sign
JO / JNO Jump if Overflow / not Overflow
JP / JNP Jump if Parity / not Parity
JZ / JNZ Jump if Zero / not Zero

Les instructions de saut sur test arithmétique signé.

JE Jump if Equal
JNE Jump if Not Equal
JG Jump if Greater
JGE Jump if Greater or Equal
JL Jump if Less
JLE Jump if Less or Equal

Les instructions de saut sur test arithmétique non signé.

JA Jump if Above
JAE Jump if Above or Equal
JB Jump if Below
JBE Jump if Below or Equal

Jelassi Khaled Microprocesseurs 8

 Les principales instructions de
l’assembleur

Les instructions de boucle: LOOP, LOOPE et LOOPNE.

Syntaxe: LOOP etiquette
LOOPE etiquette
LOOPNE etiquette

Exemple: Sommation des éléments de 0 à 100

Assembleur:
_sommation proc near
MOV CX,100
Boucle: MOV AX,0
ADD AX,CX
LOOP Boucle
_sommation endp

langage ‘C’:
int near sommation(void) {
int x=0;
_CX=100;
do {
x=x+_CX;
_CX=_CX-1;
} while (_CX!=0);
return(x);

Jelassi Khaled Microprocesseurs 9

 Les principales instructions de
l’assembleur

Les instructions sur chaînes de caractères

MOVS (ou MOVSB, MOVSW), CMPS, SCAS, LODS et STOS
Exemple:

.model small
.data
table_1 db 5 dup(?)
table_2 dw 4 dup(?)
initial_1 db 1,2,5,4,9
initial_2 dw 1000,1002,1005,1008
.code
programme proc near
mov ax,@data ; initialisation segment de donnees
mov ds,ax
mov es,ax
mov cx,5 ; 5 élément à transferer
cld ; transfert dans le sens croissant
mov si,offset initial_1 ; adresse du tableau source dans SI
mov di,offset table_1 ; adresse du tableau destination dans DI
rep movsb ; transfert des éléments de initial_1 vers table_1
mov cx,4 ; nombre d’éléments à transfere
mov si,offset initial_2 ; adresse du tableau source dans SI
mov di,offset table_2 ; adresse du tableau destination dans DI
rep movsw ; transfert des éléments de initial_2 vers table_2
mov ax,4c00h
int 21h ; Fin du programme et retour au système d’exploitation
programme endp
end programme

Jelassi Khaled Microprocesseurs 10

  Notion de procédure

Instructions CALL et RET.

L'instruction CALL effectue donc les opérations :

- Empiler la valeur de IP. A ce moment, IP pointe sur l'instruction qui suit le
CALL.
- Placer dans IP l'adresse de la première instruction de la procédure (donnée en
argument).
Et l'instruction RET :
- Dépiler une valeur et la ranger dans IP.
Exemple:

Calcul PROC near ; procedure nommee Calcul

……… ; instructions
RET ; derniere instruction
Calcul ENDP ; fin de la procedure

CALL address RET ;Retour de sous-prog

PC (PC) + 3 PCL ((SP) + 1)

(SP) (PC)H PCH ((SP) + 2)
(SP) – 1 (PC)L SP (SP) + 2
SP (SP) - 2
PC address

Jelassi Khaled Microprocesseurs 11

Passage de paramètres aux procédures

Passage de paramètres par pile

/* Programme EXEMPLE_2.C */
int ma_fonction( int x, int y ) {
return (x + y);
}
void main(void) {
int X = 11; int Y = 22; int Res;
Res = ma_fonction(X, Y);
}
_TEXT SEGMENT byte public 'CODE'
ASSUME cs:_TEXT
_main PROC near
PUSH bp
MOV bp,sp
SUB sp,6
; int X = 11;
MOV [bp-2], 11
; int Y = 22;
MOV [bp-4], 22
; int Res
; Res = ma_fonction(X, Y)
PUSH word ptr [bp-4]
PUSH word ptr [bp-2]
CALL _ma_fonction
ADD sp, 4
MOV [bp-6],ax ; }
MOV sp,bp
POP bp
RET
_main ENDP

Jelassi Khaled Microprocesseurs 12

Passage de paramètres aux procédures

Traduction de la procédure ma_fonction en assembleur

ASSUME cs:_TEXT
_ma_fonction PROC near
PUSH bp
MOV bp,sp
; return x + y;
MOV ax, [bp+4]
ADD ax, [bp+6]
POP bp
RET
_ma_fonction ENDP ;

En étudiant cet exemple, on constate que :

1. la fonction C ma_fonction() a été traduite par une procédure assembleur
nommée _ma_fonction, qui lit ses arguments à partir de la pile (pointeur BP).
2. la fonction ne modifie pas l'état de la pile;
3. Avant l'appel de la fonction (CALL ), les arguments sont empilés (PUSH).
Après le retour de la fonction, le pointeur SP est incrémenté pour remettre la pile
dans son état précédent (ADD sp, 4 est équivalent à deux instructions POP 2
octets).
4. La valeur retournée par la fonction est passée dans AX (d'où l'instruction
MOV [bp-6], ax).
Le respect des conventions d'appel de procédures est bien entendu très important
si l'on désire mélanger des fonctions C et des procédures en assembleur.

Jelassi Khaled Microprocesseurs 13

 Interfaçage assembleur-langage ‘C’

Directives USES et arg

near pascal addition PROC NEAR C USES di si, arg1:WORD, arg2:WORD,

arg3:WORD
push bp ;sauvegarde de BP
mov bp, sp ;faire pointer BP sur SP
push di ;sauvegarde de di
push si ;sauvegarde de si
mov si,arg1
mov di,arg2
mov ax,arg3
add ax,di
add ax,si
pop si ;récupération de si
pop di ;récupération de di
mov sp, bp ;remettre sp à sa valeur initiale
pop bp ;récupération de bp
ret 6 ;nettoyage de la pile
addition endp

 Appel depuis l’assembleur:

Invoke addition 1,2,3 ; en cas d’addition de 1, 2 et 3

Appel depuis le langage ‘C’:

 Addition(1,2,3);

Jelassi Khaled Microprocesseurs 14

 Assembleur et langage ’C’

Appel de procédures ‘C’ depuis l’assembleur

Cas de Printf: int Cdecl printf(const char *__format, ...);

.MODEL small, c ; Model mémoire et conventions d’appel c

.
printf PROTO NEAR, ; prototype de la fonction printf (VARAG:
;arguments variables)
pstring:NEAR PTR BYTE, num1:WORD, num2:VARARG

.DATA

format BYTE '%i %i', 13, 0 ; chaîne de caractères à afficher par printf
.CODE
_main PROC PUBLIC ; Procédure assembleur qui fait appel à
printf
.
INVOKE printf, OFFSET format, ax, bx
.
.
.
_main endp
END _main ; Fin de la procédure

Jelassi Khaled Microprocesseurs 15

 Le compilateur Assembleur

 Un petit programme réalisé avec DEBUG :

C:\DOS>debug
-a
24A2 : 0100 ORG 200
24A2 : 0200 DB "Bien le bonjour de la part de DEBUG!$"
24A2 : 0225 ORG 100
24A2 : 0100 MOV AH,09
24A2 : 0102 MOV DX,200
24A2 : 0105 INT 21
24A2 : 0107 MOV AX,4C00
24A2 : 010A INT 21
24A2 : 010C [Return]
-g
 le même programme écrit pour MASM/TASM :

DOSSEG
.MODEL SMALL
.STACK 50
.DATA
LIGNE DB "Bien le bonjour de la part de MASM/TASM!$"
.CODE
MOV AX,@DATA
MOV DS,AX
MOV AH,09H
MOV DX,OFFSET LIGNE
INT 21H
MOV AX,4C00H
INT 21H
END

Jelassi Khaled Microprocesseurs 16

 Le compilateur Assembleur

 Déclaration de variables initialisées:

.DATA
octet db -2
octets db 8 dup(0)
chaine db "Bonjour",0
mot dw 7FFFh
doubleMots dd 2 dup(0FFFFFFFFh)
nombre_reel real4 1.0

 Directives de programmation structurée:

.DATA
buf1 BYTE "This is a string",'$‘
buf2 BYTE 100 DUP (?)
.CODE
sub bx, bx ; mise à zero de bx
.WHILE (buf1[bx] != '$')
mov al, buf1[bx] ; Lire un caractère
mov buf2[bx], al ; le placer dans buf2
inc bx ; incrementation de bx
.ENDW

Jelassi Khaled Microprocesseurs 17

 Thèmes de programmation variés

Exemples de programmation:

Transfert d’éléments d’un tableau vers un autre

Calcul de la sommation des éléments d’un tableau et affichage du resultat.
Recherche du maximum d’un tableau
Recherche du minimum d’un tableau
Tri par ordre croissant d’un tableau

Remarque: Les procédures (2) et (5) doivent être écrites en langage ‘C’:

extern near pascal int TAB1[];

void pascal TRI (void){
int j,i=0; int aux;
do {
j=i+1;
do {
if (TAB1[i]>=TAB1[j]) Procédure (5)
{aux=TAB1[i]; TAB1[i]=TAB1[j];
TAB1[j]=aux;};
j++; } while(j<=4);
i++;
}while(i<=3);
}

extern near pascal int TAB1[];

int near pascal SOMME (void){
int i=0;
int somme =0;
do { somme = somme+TAB1[i]; i++; } while(i<=4) ; Procédure (2)
printf("%d",somme);
return(somme);
}

Jelassi Khaled Microprocesseurs 18

 Thèmes de programmation variés
.model small
.stack 256
.data
TAB1 dw 3,2,1,5,4
tab2 dw 5 dup(?)
Initialisation
message byte 0ah,0dh,' le resultat est: %d',0
.code
public TAB1
extern SOMME:far ; procédure ‘C’
extern _printf:far ; procédure ‘C’
extern TRI:near ; procédure ‘C’

transfert proc near

mov si,offset tab1
mov di,offset tab2
push ds
pop es
mov cx,5
rep movsw
ret
transfert endp Procédure transfert
minimum proc near
mov si,offset tab1
mov bx,[si]
mov cx,5
boucle: cmp bx,[si]
jl suite
mov bx,[si]
suite: add si,2
loop boucle
mov ax,bx
ret
minimum endp
Procédure minimum

Jelassi Khaled Microprocesseurs 19

 Thèmes de programmation variés
maximum proc near
mov si,offset tab1
mov bx,[si]
Procédure
mov cx,5
maximum
boucle:cmp bx,[si]
jg suite
mov bx,[si]
suite: add si,2
loop boucle
mov ax,bx
ret
maximum endp

_main proc near

mov ax,@data
mov ds,ax
call transfert Programme principal
call minimum
call maximum
call SOMME
push
push ax
ax
push
push ds
ds
mov
mov bx,
bx,offset
offsetmessage
message Appel de printf
push bx
push bx
call _printf
call _printf
call TRI
mov ah,4ch
int 21h
_main endp
end _main

Jelassi Khaled Microprocesseurs 20

 Traduction en assembleur de procédures ‘C’

 Procédure SOMME

48E3:1C44 55 PUSH BP
48E3:1C45 8BEC MOV BP,SP
48E3:1C47 83EC02 SUB SP,+02
48E3:1C4A 56 PUSH SI
48E3:1C4B 33F6 XOR SI,SI ; int i=0;
48E3:1C4D C746FE0000 MOV Word Ptr [BP-02],0000 ; int somme =0;
do {48E3:1C52 8BDE MOV BX,SI
48E3:1C54 D1E3 SHL BX,1
48E3:1C56 8B46FE MOV AX,Word Ptr [BP-02]
48E3:1C59 03870000 ADD AX,Word Ptr [BX+0000] ; somme+TAB1[i];
48E3:1C5D 8946FE MOV Word Ptr [BP-02],AX
48E3:1C63 46 INC SI ; i++
48E3:1C64 83FE04 CMP SI,+04 ; while(i<=4) ;
48E3:1C67 7EE9 JLE 1C52

48E3:1C69 FF76FE PUSH Word Ptr [BP-02]

48E3:1C6C 1E PUSH DS Appel de printf
48E3:1C6D B8C400 MOV AX,00C4
48E3:1C70 50 PUSH AX
48E3:1C71 90 NOP
48E3:1C72 0E PUSH CS
48E3:1C73 E875E8 CALL 04EB

48E3:1C76 83C406 ADD SP,+06

48E3:1C79 8B46FE MOV AX,Word Ptr [BP-02] ; return(somme);
48E3:1C7C EB00 JMP 1C7E
48E3:1C7E 5E POP SI
48E3:1C7F 8BE5 MOV SP,BP
48E3:1C81 5D POP BP
48E3:1C82 CB RETF

Jelassi Khaled Microprocesseurs 21