1/16

Chapitre 4 :
Programmation 32-bit pour machines 386/486

Section 4.1: Les P80386/486 en mode réel

Section 4.2: Quelques programmes avec les P80386/486

Section 4.3: Comparaison de performances entre les

P80x86

R. Beguenane, UQAC, 2002/2003 Systèmes à microprocesseurs

 2/16

Objectives
Les objectifs de ce chapitre sont:
- Expliquer les différences majeurs entre les P8086/286, et les
P80386/486.
- Lister les registres des P80386/486.
- Expliquer les différences dans l’utilisation des registres entre les
P8086/286, et les P80386/486.
- Discuter comment l’augmentation de la taille des registres des
P80386/486 est liée à l’augmentation de la mémoire.
- Expliquer la convention Little Endian avec les opérandes double-
mots des P80386/486.
- Expliquer les nouvelles directives et l’utilisation des registres
étendus dans les programmes destinées aux P80386/486.
- Décrire les facteurs conduisant à l’amélioration des performances
avec les P80386/486 comparées avec les P8086/286.
R. Beguenane, UQAC, 2002/2003 Systèmes à microprocesseurs
 3/16

Section 4.1 Les P80386/486 en mode réel

- Différence 1: Les registres P8086/286 ont une taille maximum de 16 bits. La taille
maximum des registres P80386/486 est étendue à 32 bits.

15 8 7 0
YH YL
Y = A, B, C, ou D
YX
31 0

EYX

Z
31 16 15 0
Z = DI, SI, BP, ou SP
EZ

XS
15 0
Z = C, D, S, E, F, ou G
31
En bleu  mode protégé.
EIP, EFR, CR0, CR1, CR2, ou CR3 En mode réel, IP et FR  16 bits

R. Beguenane, UQAC, 2002/2003 Systèmes à microprocesseurs

 4/16

Les P80386/486 en mode réel

- Différence 2: Les registres EAX, ECX, et EDX des P80386/486 peuvent être utilisés
comme pointeurs. Alors que pour les P8086/286, AX, CX, et DX ne peuvent l’être:
MOV AX, [ECX] ; ECX comme pointeur ou offset  DS:ECX
ADD SI, FS:[EDX] ; EDX comme offset avec écrasement du segment défaut DS (FS:EDX)
OR EBX, [EAX] + 15 ;  DS:EAX (Ex. en mode réel : 12E0:00000120  14000H)
MOV BX, [CX] ; Erreur!! CX ne peut être pointeur

-Étendue de la mémoire en mode réel des P80386/486 : Si celle-ci est de 1MegaOctet, et qu’un
registre 32-bits (comme EAX) est utilisé comme segment offset, le programmeur s’assure de mettre le
mot le plus significatif à 0, sinon il risque de placer l’adresse mémoire au delà de 1MegaOctet
(notamment avec les PC 386/486 avec DOS <5):
MOV AX, WORD PTR[ECX] ; ECX comme pointeur 16 bits  DS:ECX

-Convention ‘Little Endian’ : Avec les P8086/286, la sauvegarde des données 32 bits en
mémoire ou le chargement d’opérandes 32-bits dans des registres, se fait en respectant la
convention ‘Little Endian’ d’Intel. Celle-ci, pour rappel, consiste à associer l’octet le moins
significatif à l’adresse la moins significative et vice versa.

OFFSET Contenus
RESULTAT D0 – d7

RESULTAT +1 D8 – d15

RESULTAT +1 D16 – d23

RESULTAT +1 D24 – d31

R. Beguenane, UQAC, 2002/2003 Systèmes à microprocesseurs

 5/16
Section 4.2 Quelques programmes
avec les P80386/486
Une solution pour augmenter la puissance de traitement d’un P est d’élargir la taille de ses registres. Ceci
permettra de traiter les grands nombres comme un tout au lieu de les séparer en octets ou mots de 16 bits. A
travers quelques exemples, on verra l’impact sur la vitesse d’exécution en codant avec les registres 32-bits au
lieu des registres 16-bits.
ADDITION DES MOTS 16-BITS AVEC REGISTRES 16-BITS (P8086/286)
-TITLE prog3_1b.asm: Reprendre l’exemple de l’Addition de 5 mots de 16 bits (27345, 28521, 29533, 30105, et 32375)
.MODEL SMALL
.STACK 64
.DATA
DATA DW ? ; nous avons 15 mots se trouvant dans le segment de donnees a partir d’offset 0
ORG 0020H
SOMME DW 2 DUP(?)
COMPTE EQU 5
.CODE
MAIN PROC FAR
MOV AX, @DATA MOV DS, AX
MOV CX, COMPTE
MOV SI, OFFSET DATA
MOV AX, 00
MOV BX, AX ; BX  pour les retenues
ENCORE: ADD AX, [SI] ; Ajouter le contenu de AX au prochain mot
ADC BX, 0 ; ajouter la retenue à BX
INC SI INC SI ; deux fois car c’est l’addition des mots (ou bien ADD SI + 2 )
DEC CX
JNZ ENCORE
MOV SOMME, AX
MOV SOMME +2, BX ; stocker les retenues
INT 3
MAIN ENDP
END MAIN
R. Beguenane, UQAC, 2002/2003 Systèmes à microprocesseurs
 6/16

Quelques programmes avec les P80386/486

ADDITION DES MOTS 16-BITS AVEC REGISTRES 32-BITS (P80386/486)
TITLE prog4_1.asm: Reprendre l’exemple de l’Addition de 5 mots de 16bits (27345, 28521, 29533, 30105, 32375) mais avec des registres 32-bits

.MODEL SMALL
.386 ; exécuter avec PC386 et plus. (.386 avec MASM, sinon P386 avec TASM)
.STACK 200H
.DATA
DATA1 DD 6AD1h, 6F69h, 735Dh, 7599h, 7E77h ; dans le mémoire  00006AD1h, 00006F69h, …, 00007E77h
ORG 0020H
SOMME1 DD ?
COMPTE EQU 5
.CODE
DEBUT: MOV AX, @DATA
MOV DS, AX
MOV CX, COMPTE
MOV SI, OFFSET DATA1
SUB EAX, EAX ; initialiser EAX, ou bien MOV EAX, 0
ENCORE: ADD EAX, DWORD PTR[SI] ; Ajouter le prochain mot au registre EAX
ADD SI + 4 ; SI pointe au prochain double-mot (DD)
DEC CX ; Noter: Pas besoin de la retenue (ADC) car les mots les plus significatifs
; des double-mots sont 0000H, donc c’est sur pas de retenue

JNZ ENCORE
MOV SOMME1, EAX
MOV AH, 4CH
INT 21H
END DEBUT
Avantage: Pas besoin d’utiliser 2 registres AX et BX (pour les retenues), ici un seul suffit (EAX), d’ou le gain de 2 instructions
à éviter (MOV BX, AX et ADC BX, 0)

R. Beguenane, UQAC, 2002/2003 Systèmes à microprocesseurs

 7/16

Quelques programmes avec les P80386/486

ADDITION DE DONNEES MULTI-MOTS AVEC REGISTRES 16-BITS (P 8086/286)

TITLE prog3_2.asm: Reprendre l’Addition de 2 multi-mots (548FB9963CE7h et 3FCD4FA23B8Dh) avec les P8086/286
.MODEL SMALL
.STACK 64
.DATA
DATA2 DQ 548FB9963CE7H ; DQ  reserver un espace memoire pour une donnée large de 8 octets
ORG 0010H
DATA3 DQ 3FCD4FA23B8DH
ORG 0020H
SOMME23 DQ ?
.CODE
MAIN PROC FAR
MOV AX, @DATA
MOV DS, AX
CLC ; reset la retenue
MOV SI, OFFSET DATA2 ; SI est pointeur vers l’opérande DATA2
MOV DI, OFFSET DATA3 ; DI est pointeur vers l’opérande DATA3
MOV BX, OFFSET SOMMM23 ; BX est pointeur vers la somme SOMMM23
MOV CX, 04 ; compteur de boucle
ENCORE: MOV AX, [SI] ; déplace le 1er opérande vers AX
ADC AX, [DI] ; add. le 2eme opérande vers AX en tenant compte de la retenue précédente
MOV [BX], AX ; stocke la somme dans la case mémoire pointée par BX
INC SI INC SI ; pointe sur le prochain mot de l’opérande DATA2 (mieux avec ADD SI, 2 )
INC DI INC DI ; pointe sur le prochain mot de l’opérande DATA3 (mieux avec ADD DI, 2 )
INC BX INC BX ; pointe sur le prochain mot de de SOMMM23 (mieux avec ADD BX , 2)
LOOP ENCORE ; Instruction équivalente a [ DEC CX, JNZ ENCORE ]
MOV AH, 4Ch
INT 21h
MAIN ENDP
END MAIN

R. Beguenane, UQAC, 2002/2003 Systèmes à microprocesseurs

 8/16

Quelques programmes avec les P80386/486

ADDITION DE DONNEES MULTI-MOTS AVEC REGISTRES 32-BITS (P 80386/486)
TITLE prog4_2.asm: Addition de 2 multi-mots (548FB9963CE7h et 3FCD4FA23B8Dh) avec les P80386/486
.MODEL SMALL
.386
.STACK 64
.DATA
DATA2 DQ 548FB9963CE7H Avantage: 2 Itérations au lieu de 4 (2CX)
ORG 0010H
DATA3 DQ 3FCD4FA23B8DH
ORG 0020H Noter l’utilisation de PUSHF et POPF pour sauvegarder et
SOMME23 DQ ? restaurer CF (à travers FR), avant l’itération suivante, sinon
.CODE l’instruction après PUSHF (ADD SI, 4) met à zéro CF.
DEBUT: MOV AX, @DATA
MOV DS, AX
CLC
MOV SI, OFFSET DATA2 ; SI est pointeur vers l’opérande DATA2
MOV DI, OFFSET DATA3 ; DI est pointeur vers l’opérande DATA3
MOV BX, OFFSET SOMMM23 ; BX est pointeur vers la somme SOMMM23
MOV CX, 02 ; compteur de boucle
ENCORE: MOV EAX, DWORD PTR[SI] ; le prochain double-mot du 1er opérande  EAX
ADC EAX, DWORD PTR[DI] ; l’additionner au prochain double-mot du 2eme opérande + retenue  EAX
MOV DWORD PTR[BX], EAX ; stocker le prochain double-mot de la somme dans 2 cases mémoire: [ BX ]
PUSHF ; Sauvegarder FR, ( sauvegarder CF)
ADD SI, 4 ; pointe sur le prochain double-mot de l’opérande DATA2 (= 4 x INC SI)
ADD DI, 4 ; pointe sur le prochain double- mot de l’opérande DATA3
ADD BX , 4 ; pointe sur le prochain double- mot de de SOMMM23
POPF ; Restaurer FR ( retrouver CF d e l’addition précédente)
LOOP ENCORE
MOV AH, 4Ch INT 21h
END DEBUT
R. Beguenane, UQAC, 2002/2003 Systèmes à microprocesseurs
 9/ 16

Quelques programmes avec les P80386/486

L’utilisation du concept de boucle ou des instructions de Saut, est très pénalisant. Cette nouvelle version du
‘prog4.2’ permet d’améliorer le rendement et la performance du P en évitant les boucles. Cette version est
utile si les nombres à additionner sont raisonnables en largeur (comme dans ce cas de nombres à 8
octets)

TITLE prog4_2b.asm: Addition de 2 multi-mots (548FB9963CE7h et 3FCD4FA23B8Dh) avec les P80386/486

.MODEL SMALL
.386
.STACK 64
.DATA
DATA2 DQ 548FB9963CE7H ; DQ  un espace mémoire pour une donnée large de 8 octet
ORG 0010H
DATA3 DQ 3FCD4FA23B8DH
ORG 0020H
SOMME23 DQ ?

.CODE
DEBUT: MOV AX, @DATA
MOV DS, AX
MOV EAX, DWORD PTR DATA2 ; Charger EAX avec le 1er double-mot du 1er opérande
ADD EAX, DWORD PTR DATA3 ; l’additionner avec le 1er double-mot du 2eme opérande
MOV EBX, DWORD PTR DATA2+4 ; Charger EBX avec le 2eme double-mot du 1er opérande
ADC EBX, DWORD PTR DATA3+4 ; l’additionner avec le 2eme double-mot du 2eme opérande , en tenant
; compte de la retenue
MOV DWORD PTR SOMME23,EAX ; Sauvegarder le 1er double-mot du résultat
MOV DWORD PTR SOMME23+4, EBX ; Sauvegarder le 2eme double-mot du résultat
MOV AH, 4Ch
INT 21h
END DEBUT
Note:Quoique les variables DATA2,3 et SOMME23 sont définis comme données 8 octets (DQ) mais elles sont accéder en DWORD, pour
les déplacer vers des registres 32 bits (EAX, EBX), d’ou la directive PTR pour spécifier la taille des opérandes DATA2, 3 et SOMME23.
R. Beguenane, UQAC, 2002/2003 Systèmes à microprocesseurs
 10/ 16

Quelques programmes avec les P80386/486

MULTIPLICATION D’UN OPERANDE 32-BITS AVEC UN OPERANDE 16-BITS
AVEC REGISTRES 16-BITS (P 8086/286)
Mi=16-bits

Règle: M2M1 x M3 = 0000(M1xM3)+ (M2xM3)0000H, M1, M2, et M3 sont des mots de 16bits

48-bits
TITLE prog4_3.asm: Multiplication d’un double-mot de 32-bits par un mot de 16-bits avec les P8086/286
.MODEL SMALL .STACK 200H
.DATA
MUL_CANDE DD 500000 ; DD  un espace mémoire pour une donnée de 4 octets (Multiplicande est de 32 bits) 0007A120h
MULTIPLIEUR DW 50000 ; DW  un espace mémoire pour une donnée de 2 octets (Multiplieur est de 16 bits) C350h

PRODUIT DQ ? ; DQ  un espace mémoire pour une donnée de 8 octets ( Résultat est sur 48 bits)
.CODE
DEBUT: MOV AX, @DATA MOV DS, AX
MOV AX, WORD PTR MUL_CANDE ; Charger vers AX le mot le MOINS significatif du multiplicande
MUL WORD PTR MULTIPLIEUR ; le multiplier par le multiplieur, le résultat et sur [DX, AX]
MOV WORD PTR PRODUIT, AX ; Sauvegarder le mot le MOINS significatif du produit
MOV WORD PTR PRODUIT+2, DX ; Sauvegarder le mot le PLUS significatif du produit
MOV AX, WORD PTR MUL_CANDE+2 ; Charger vers AX le mot le PLUS significatif du multiplicande
MUL WORD PTR MULTIPLIEUR ; Multiplier le par le multiplieur, le résultat et sur [DX, AX]
ADD WORD PTR PRODUIT+2, AX ; Ajouter le mot 16-bit du milieu
ADC DX, 0 ; Propager la retenue vers DX (le 3eme mot du produit)
MOV WORD PTR PRODUIT+4, DX ; Sauvegarder le mot le PLUS significatif du produit (le 3eme mot)
MOV AH, 4Ch INT 21h
END DEBUT

R. Beguenane, UQAC, 2002/2003 Systèmes à microprocesseurs

 11/ 16

Quelques programmes avec les P80386/486

MULTIPLICATION D’UN OPERANDE 32-BITS AVEC UN OPERANDE 16-BITS
AVEC REGISTRES 32-BITS (P 80386/486)
EAX Multiplier un registre 32-bits.

par un opérande 32-bits.

EDX EAX Le produit est sauvegardé dans [EDX, EAX]

TITLE prog4_4.asm: Multiplication d’un double-mot de 32-bits par un mot de 32-bits avec les P80386/486
.MODEL SMALL
.386 .STACK 200H
.DATA
MUL_CANDE DD 500000 ; DD  un espace mémoire pour une donnée de 4 octets (Multiplicande est de 32 bits)
MULTIPLIEUR DD 50000 ; DD  Espace mémoire de 4 octets pour le Multiplieur (16 bits mais étendu à 32 par des ‘0’)
PRODUIT DQ ? ; DQ  un espace mémoire pour une donnée de 8 octets ( Résultat est sur 48 bits)
.CODE
DEBUT: MOV AX, @DATA
MOV DS, AX
MOV EAX, MUL_CANDE ; Charger le double-mot multiplicande  EAX
MUL DWORD PTR MULTIPLIEUR ; le multiplier par le multiplieur, le résultat et sur [EDX, EAX]
MOV DWORD PTR PRODUIT, EAX ; Sauvegarder le double-mot le MOINS significatif du produit
MOV DWORD PTR PRODUIT+4, EDX ; Sauvegarder le double-mot le PLUS significatif du produit
MOV AH, 4Ch
INT 21h
END DEBUT

Avantages:Réduction du nombre d’instructions de 14 à 9. L’instruction MUL est utilisée une seule fois. Pas d’instruction ADD.

R. Beguenane, UQAC, 2002/2003 Systèmes à microprocesseurs

 12/ 16
Section 4.3 :
Comparaison de performances entre les P80x86

Il vient d’être montrer comment coder avec des registres 32-bits des P80386/486
est plus rentable qu’en utilisant les registres 16-bits des P8086/286.

Dans ce qui suit, nous allons comparer les performances des différents P80x86.
La comparaison, en termes de vitesse d’exécution des instructions, se fait en
nombre de cycles d’horloge et non pas en temps absolu. Ce temps dépend de la
conception hardware du système, plus particulièrement de la fréquence d’horloge et
de la conception de la mémoire.
La stratégie de la comparaison des performances de la famille 80x86 des P Intel, est
basée sur ces deux approches:

1. Prendre le même programme, écrit pour le P8086, l’exécuter sur d’autres P80x86,
et calculer le nombre de cycles d’horloge que nécessite chaque P.

2. Modifier le programme en question pour l’adapter aux facilités qu’offre

l’introduction des registres 32-bits des P80386/486, et calculer le nombre de
cycles d’horloge que nécessite son exécution pour chacun des P80386 et
P80486.
Note: Les manuels d’Intel donne le nombre de cycles d’horloge pour chaque instruction 80x86 (Voir
Appendice B du livre). Avec les P80386/486, Intel a utilisé des techniques avancées de Pipeline pour
améliorer la puissance de traitement des instructions (en moyenne de 4 à 5 cycles  1 à 2 cycles d’horloge).

R. Beguenane, UQAC, 2002/2003 Systèmes à microprocesseurs

 13/ 16

Comparaison de performances entre les P80x86

Exécution d’un programme 8086 sur des PC à base de 80x86

Dans le premier programme (prog3_1b.asm) de ce chapitre (addition de CX=5 données en octets), il
existe cette boucle:
ENCORE: ADD AX, [SI]
ADC BX, 0
INC SI
INC SI
DEC CX
JNZ ENCORE

Les temps d’exécution en cycles d’horloges pour les différents P80x86 sont les suivants:

INSTRUCTION 8086 80286 80386 80486

ENCORE: ADD AX, [SI]
14 7 6 2
ADC BX, 0
4 3 2 1
INC SI
2 2 2 1
INC SI
2 2 2 1
DEC CX
2 2 2 1
JNZ ENCORE
16 (saut)/4 (pas de saut) 7 /3 7/3 3/1
Cycles horloge / Itération
40 (les sauts uniquement) 23 21 9
Nombre de cycles total 188 [ 40 x 5 –(16- 4) ] 111 101 (2 x plus rapide que 8086) 43 (4 x plus rapide que 8086)

+ Registres 32-bits
R. Beguenane, UQAC, 2002/2003 Systèmes à microprocesseurs
 14/ 16

Comparaison de performances entre les P80x86

Exécution du même programme 8086 réécrit pour le 80386/486

Dans le deuxième programme (prog4_1.asm) de ce chapitre (addition de CX=5 données en

octets), l’exécution de la boucle réduite avec les P386/486 donne le résultat suivant:

INSTRUCTION 80386 80486

ENCORE: ADD EAX, DWORD PTR [SI]
6 2
ADD SI, 4
ENCORE: ADD EAX, DWORD PTR [SI] 2 1
ADD SI, 4
DEC CX
DEC CX 2 1
JNZ ENCORE
JNZ ENCORE
7/3 3/1
Cycles horloge / Itération
17 7
Nombre de cycles total 81 33

Conclusion: Le réécriture du programme 16-bits avec la version 32-bits (registres des P80386/486),
permet d’accélérer l’exécution d’environ 25%.

R. Beguenane, UQAC, 2002/2003 Systèmes à microprocesseurs

 15/ 16

Comparaison de performances entre les P80x86

Exécution d’un programme 8086 sur des PC à base de 80x86 (Exemple 2)

Dans l’exemple du programme (prog3_2.asm) de ce chapitre (addition de données en multi-mots), la

boucle est plus longue:
ENCORE: MOV AX, [SI]
ADC AX, [DI]
MOV [BX], AX
INC SI INC SI
INC DI INC DI
INC BX INC BX
LOOP ENCORE

INSTRUCTION 8086 80286 80386 80486

ENCORE: MOV AX, [SI]
10 5 4 1
ADC BX, [DI]
14 7 6 2
MOV [BX], AX
10 3 2 1
INC SI (2 fois)
4 4 4 2
INC D I(2 fois)
4 4 4 2
INC BX (2 fois)
4 4 4 2
JNZ ENCORE
17 (saut)/5 (pas de saut) 10 /4 13 / 11 7/6
Cycles horloge / Itération
53 (les sauts uniquement) 37 37 17
Nombre de cycles total 200 [ 53 x 4 –(17- 5) ] 142 146 67 (3 x plus rapide que 8086)
R. Beguenane, UQAC, 2002/2003 Systèmes à microprocesseurs
 16/ 16

Comparaison de performances entre les P80x86

Exécution du même programme 8086 réécrit pour le 80386/486 (Exemple 2)

En reprogrammant autrement l’exemple précédent, sans boucle, cela donne le programme

prog4.2.asm, dont le nombre de cycles d’horloge de la partie principale du programme est comme
suit:
INSTRUCTION 80386 80486
MOV EAX, DWORD PTR DATA2 MOV EAX, DWORD PTR DATA2 4 1
ADD EAX, DWORD PTR DATA3 ADD EAX, DWORD PTR DATA3
MOV EBX, DWORD PTR DATA2+4
6 2
ADC EBX, DWORD PTR DATA3+4 MOV EBX, DWORD PTR DATA2+4 4 1
MOV DWORD PTR SOMME23,EAX
ADC EBX, DWORD PTR DATA3+4 6 2
MOV DWORD PTR SOMME23+4, EBX

MOV DWORD PTR SOMME23, EAX 2 1

MOV DWORD PTR SOMME23+4, EBX 2 1
Nombre de cycles total 24 8
Ainsi, en utilisant le même hardware mais en changeant seulement le software pour prendre
avantage des registres 32-bits des P80386/486, ceci permet d’accélérer la puissance du
traitement de 6 fois pour 386, et de 8.5 fois pour 486.

Cette exemple montre que la pénalité induite par l’introduction de boucles ou de saut dans la
programmation est énorme en termes de vitesse d’exécution. Ceci montre a quel point il est
avantageux de réécrire les anciens programmes 16-bits pour les adapter aux nouvelles
architectures 32-bits.
R. Beguenane, UQAC, 2002/2003 Systèmes à microprocesseurs
 Devoir_4
1. Indiquer le contenu de chacun des registre suivants: AL, AH, AX, et EAX après l’exécution de
cette instruction: MOV EAX, 9823F4B6h.

2. En utilisant la convention ‘Little Endian’, montrer les contenus de la destination dans chacun des
cas suivants:
a- MOV [SI], EAX ; Avec SI = 2000h, EAX = 9823F456h
b- MOV [BX], ECX ; Avec BX = 348Ch, ECX = 1F23491h
c- MOV EBX, [DI] ; Avec DI = 4044h, DS:4044 = (92)
; DS:4045 = (6D), DS:4046 = (A2), DS:4047 = (4C)
3.
a- Écrire un programme pour le P8086/286 qui permet de transférer 50 mots de données, un mot
(16-bits) à la fois.
b- Modifier le programme précédent en transférant des double-mots à la fois (32-bits) pour le
P80386/486.
c- Dans les deux cas précédents, calculer le nombre total de cycles d’horloge nécessaires à
l’exécution des deux programmes.

4. L’instruction DAA, vue dans le chapitre précédent, utilise seulement le registre AL, quelque soit
le type du P d’Intel (80x86) utilisé.

a- Écrire un programme qui permet d’additionner 2 nombres multi-octets en BCD Paqueté,

chacun possédant 10 octets (utiliser la directive DT).

b- Comparer le le nombre total de cycles d’horloge nécessaires à l’exécution du même

programme avec les P d’Intel suivants: 8086, 80286, 80386, 80486.
Note: Au besoin, utiliser l’appendice des temps d’exécution des instructions dans le livre.

R. Beguenane, UQAC, 2002/2003 Systèmes à microprocesseurs