Emulation graphique du fonctionnement dun microprocesseur 8086

I. Prsentation du sujet
Lapprentissage de la programmation passe par la connaissance de larchitecture des
ordinateurs, et en particulier par la comprhension de son lment central, savoir le
microprocesseur. Celle-ci peut tre ralise de deux manires complmentaires : soit dun point de
vue purement lectronique, cest--dire axe sur ses composants, soit dun point de vue fonctionnel,
plutt axe sur son mode de fonctionnement.
Cette deuxime approche induit la dcouverte, pour chaque microprocesseur, de langages de
bas niveau tels que le langage machine ou le langage dassemblage. Cette tape peut prsenter
quelques difficults, car les langages impratifs sont gnralement les seuls langages que
connaissent les tudiants. Or, ces langages, tant de haut niveau, nimposent pas un dcoupage aussi
strict des oprations effectues. Entres autres, labsence de structures de contrle telles que les if
ou les while , ainsi que de tableaux ou denregistrements dsaronne les nophytes.
Lobjectif de ce projet est de crer une application permettant de simuler lexcution dun
programme crit dans un langage dassemblage ressemblant celui du microprocesseur 8086. Cette
simulation ayant pour but de faciliter la comprhension dun langage dassemblage, elle se doit de
prsenter clairement lordre dexcution des instructions, leur impact sur les donnes, ainsi que sur
les diffrents lments manipuls par ce microprocesseur, que sont la pile, les registres et les flags.
Il existe dj de tels dbogueurs dans le commerce, mais lapprentissage de leur syntaxe et
de leur mode de fonctionnement ncessite de passer de nombreuses heures compulser la
documentation. Notre but est de crer un interprteur minimaliste, dun sous-ensemble du langage
dassemblage du 8086, trs rapidement comprhensible, mme pour un utilisateur nayant que peu
de connaissances sur ce microprocesseur.
Le langage retenu pour effectuer le dveloppement de cette application est Java. Lintrt
dutiliser ce langage est que Java est un langage objets, ce qui a permis deffectuer une modlisation
du problme sous forme de classes. A cela sajoutent les fonctionnalits offertes par ce langage en
terme dInterfaces Homme-Machine.
Dans un premier temps, nous allons prsenter succinctement les principales caractristiques
du microprocesseur Intel 8086. Ensuite nous aborderons nos choix dimplmentation, la
modlisation effectue et le fonctionnement de la partie mulant le 8086. Enfin, nous nous
intresserons plus particulirement lutilisation de linterface graphique de lapplication.

Page 1

/ 20

Emulation graphique du fonctionnement dun microprocesseur 8086

II. Rappels sur le microprocesseur Intel 8086

Dvelopp en 1978 par Intel, le microprocesseur 8086 est un processeur CISC 16 bits. Il
sagit du premier microprocesseur de la famille des x86 comprenant les clbres 80386 et
80486.
Ses caractristiques principales sont les suivantes :
Bus de donnes dune largeur de 16 bits.
Bus dadresses de 20 bits, ce qui permet dadresser un total de 1 mgaoctet de mmoire.
14 registres de 16 bits dont un registre dtat contenant des indicateurs binaires.
La mmoire est segmente en 16 blocs de 64 Ko et une adresse sur 20 bits est obtenue en
combinant deux parties :

Le registre CS permet de stocker les 4 bits de poids fort donnant le numro de

segment de mmoire ;

Le registre IP fournit les 16 bits de poids faible donnant ladresse lintrieur du

segment de mmoire spcifi par CS.

Ladresse mmoire est retrouve selon la formule :

adresse = (16 x CS) + IP.
Le 8086 autorise un mode de fonctionnement en pas pas, ainsi que lutilisation
doprations spcifiques appeles interruptions permettant au 8086 de dialoguer avec les autres
priphriques de lordinateur.
Les registres du 8086 se dcomposent en 4 grandes familles :
4 registres de donnes, se dcomposant chacun en deux parties : une partie haute
et une partie basse de 8 bits chacune, ce qui permet au microprocesseur de
manipuler des donnes sur 8 ou 16 bits :
-

AX (dcomposable en AH et AL) sert daccumulateur et est principalement

utilis lors doprations arithmtiques et logiques ;
BX est la plupart du temps utilis comme oprande dans les calculs ;
CX est utilis comme compteur dans les structures itratives ;
DX, tout comme AX, est utilis pour les calculs arithmtiques et notamment
dans la division et la multiplication. Il intervient galement dans les
oprations dentres/sorties.

registres de segmentation :
-

CS (segment de code) permet de dterminer les adresses sur 20 bits ;

DS (segment de donnes) ;
SS (segment de pile) ;
ES (segment supplmentaire).

Page 2

/ 20

Emulation graphique du fonctionnement dun microprocesseur 8086

registres pointeurs ou dindex :

-

SP (pointeur de pile) pointe sur le sommet de la pile de donnes ;

BP (pointeur de base) pointe sur la base de la pile de donnes ;
SI (index de source) ;
DI (index de destination).

pointeur dinstruction : IP stocke ladresse de la prochaine instruction excuter par

le microprocesseur.
registre spcial contenant 9 indicateurs binaires nomms flags :
-

AF (indicateur de retenue auxiliaire) ;

CF (indicateur de retenue) est mis 1 lorsquil y a eu une retenue lors dun
calcul ;
OF (indicateur de dbordement) est mis 1 lorsquun dbordement
arithmtique a eu lieu (lorsque le rsultat dune opration ne peut tenir sur 16
bits) ;
SF (indicateur de signe) reprsente le signe du rsultat dune opration (0 =
positif, 1 = ngatif) ;
PF (indicateur de parit) est mis 1 lorsque le rsultat dune opration
contient un nombre pair de 1 ;
ZF (indicateur de zro) est mis 1 lorsque le rsultat dune opration vaut 0 ;
DF (indicateur de direction) ;
IF (indicateur dautorisation dinterruption) ;
TF (indicateur dinterruption pas pas).

Le 8086 est programmable dans un langage dassemblage comportant des instructions

utilisant les registres, les flags, la mmoire et, en ce qui concerne les interruptions, dautres
lments de lordinateur. Voici un aperu des instructions les plus couramment utilises (dans la
liste qui suit, les mots entre parenthses indiquent le nom de linstruction). Ces instructions seront
tudies plus en dtail dans la section consacre la partie CPU de notre mulateur.
Instructions arithmtiques : addition (ADD), soustraction (SUB), multiplication (MUL),
division (DIV), incrmentation (INC), dcrmentation (DEC) et change (XCHG) ;
Instructions logiques : et (AND), ou (OR) et non (NOT) ;
Instruction de comparaison (CMP) : met jour les flags pour permettre lutilisation des
instructions de saut ;
Instructions de saut : saut si gal (JE), saut si diffrent (JNE), saut si infrieur (JL),
Instructions de gestion de la pile : empilement (PUSH) et dpilement (POP)
Instruction dappel (CALL) et de retour (RET) ;
De nombreuses autres instructions que nous ne dtaillerons pas ici.

Page 3

/ 20

Emulation graphique du fonctionnement dun microprocesseur 8086

III. Modlisation de lmulateur

1. Caractristiques gnrales
Simuler compltement le fonctionnement dun 8086 aurait demand un travail considrable
car ses proprits sont nombreuses. La dure impose pour le stage nous a conduit slectionner
celles qui nous ont paru essentielles.
La gestion de la mmoire la manire du 8086 ntant pas non plus lobjectif principal de
lmulateur, nous avons opt pour un systme mi-chemin entre celle-ci et celle propose dans un
langage impratif comme le Pascal. Cette gestion passe donc par lutilisation de variables et de
tableaux, au lieu de segments. Le type dune variable ou dun lment dun tableau est
systmatiquement un entier non sign sur 16 bits, ce qui autorise les valeurs de 0 65535.
Au niveau du processeur, les registres supports sont au nombre de 7 : les registres de
donnes (AX, BX, CX, DX), les deux registres pointeurs de pile (BP et SP) et le pointeur
dinstruction IP. Les autres registres ont t laisss de cot en raison de leur utilisation dans les
interruptions (abandonnes du fait dune trop grande complexit) et la gestion de la mmoire par
segments. Les flags conservs sont ZF, CF, OF et SF, les autres ayant t rejets car nintervenant
pas dans les instructions que nous avons choisi de supporter.
La pile, quand elle, est gre non pas comme une partie de la mmoire centrale mais
comme une pile de donnes pouvant contenir des adresses et des valeurs.
Le langage dassemblage support par notre mulateur a t dtermin en ralisant un
compromis entre le langage dassemblage rel du 8086 et notre besoin de supporter les variables et
les tableaux. Le besoin de raliser des sauts dune instruction une autre sans passer par la mmoire
ont t rendus possibles par lutilisation dtiquettes places dans le texte du programme crit dans
notre langage.
Un programme est crit sous forme de texte et doit comporter deux sections :
-

la premire, introduite par le mot-cl DATA seul sur une ligne, est la partie de
dclaration des variables et des tableaux. Dans cette partie, on peut dclarer une
variable ou un tableau par ligne, avec la syntaxe suivante pour une variable :
nom_de_variable DW valeur_initiale

et celle-ci pour un tableau :

nom_de_tableau DW[taille]

A titre de rappel, notre mulateur ne permet que de supporter les donnes reprsentes
par des mots non signes sur 16 bits, ce qui nautorise que les valeurs entires
comprises entre 0 et 65535.
-

la seconde, introduite par le mot-cl CODE seul sur une ligne, qui se termine la fin du
fichier, consiste en une liste dinstructions excuter. Ces instructions peuvent
comporter des tiquettes, et faire intervenir les variables et les tableaux dclars dans
la section DATA, ainsi que les registres et des constantes numriques. Chaque ligne ne
peut contenir quune instruction ou une tiquette.

Page 4

/ 20

Emulation graphique du fonctionnement dun microprocesseur 8086

Un programme peut en outre comporter des lignes vides ou des lignes de

commentaires, lesquelles doivent chacune dbuter par un point-virgule.
Les instructions supportes sont les suivantes :
Nom
PUSH
POP
MOV

CALL
RET
ADD

SUB

MUL

DIV

CMP

Formes acceptes
PUSH reg
POP reg
MOV reg1, reg2
MOV reg , var
MOV var , reg
MOV reg , cste
MOV reg1 , tableau[reg2]
MOV tableau[reg1], reg2
CALL etiquette
RET
ADD
ADD
ADD
ADD
SUB
SUB
SUB
SUB
MUL
MUL
MUL
MUL
DIV
DIV
DIV
DIV

reg , cste
reg1, reg2
reg , var
reg1, tableau[reg2]
reg , cste
reg1, reg2
reg , var
reg1, tableau[reg2]
cste
reg
var
tableau[reg]
cste
reg
var
tableau[reg]

JUMP
JE
JNE
JG
JGE
JL
JLE
INC
DEC
NOT

CMP reg , cste

CMP reg1, reg2
CMP reg , var
CMP reg1, tableau[reg2]
JUMP etiquette
JE etiquette
JNE etiquette
JG etiquette
JGE etiquette
JL etiquette
JLE etiquette
INC reg
DEC reg
NOT reg

AND
OR

AND reg1, reg2

OR reg1, reg2

XCHG
LIRE

XCHG reg1, reg2

LIRE reg
LIRE var
LIRE tableau[reg]
ECRIRE cste
ECRIRE reg
ECRIRE var
ECRIRE tableau[reg]

ECRIRE

Description
Empile le contenu du registre
Dpile dans le registre spcifi
Affecte le contenu du second paramtre au premier paramtre. Le
second paramtre reste inchang.

Branchement sur une tiquette. La ligne depuis lequel sest fait le

branchement est place dans la pile.
Retour une ligne dont le numro a t plac en sommet de pile.
Addition des valeurs des deux paramtres. Le rsultat est stock
dans le premier paramtre, tandis que le second reste inchang.
Les flags sont mis jour.
Soustraction des valeurs des deux paramtres. Le rsultat est
stock dans le premier paramtre, tandis que le second reste
inchang. Les flags sont mis jour.
Multiplication de la valeur du paramtre par le contenu du registre
AX. Le rsultat est stock dans AX. Les flags sont mis jour.
Division entire du contenu du registre AX par la valeur du
paramtre. Le quotient est stock dans AX, et le reste est plac
dans DX. Les flags sont mis jour. En cas de division par zro,
lexcution est interrompue.
Soustraction de la valeur du second paramtre la valeur du
premier paramtre. Le rsultat nest pas restitu, mais les flags
sont mis jour pour permettre les instructions de saut.
Sauts conditionnels ltiquette donne en paramtre. Laction
dune instruction de saut dpend de la valeur des flags.

Incrmentation/Dcrmentation de la valeur du registre spcifi.

Les flags sont mis jour.
Ngation logique de la valeur du registre. Le rsultat est stock
dans le registre. Les flags sont mis jour.
ET/OU logique des deux valeurs des registres. Le rsultat est
stock dans le registre reg1, tandis que reg2 est inchang. Les
flags sont mis jour.
Permute les contenus des deux registres.
Lecture dune valeur et stockage dans le paramtre. La mthode
de saisie nest pas dfinie au niveau du processeur.
Ecriture de la valeur du paramtre. La mthode dcriture nest
pas dfinie au niveau du processeur.

La gestion des entres/sorties par le microprocesseur 8086 seffectue par le biais

dinterruptions faisant intervenir dautres priphriques. Dans un souci de simplicit, nous avons
remplac ce mcanisme par deux instructions permettant les entres/sorties de valeurs numriques.

Page 5

/ 20

Emulation graphique du fonctionnement dun microprocesseur 8086

Linstruction LIRE ralise une demande dune valeur numrique depuis lmulateur, tandis
que linstruction ECRIRE ralise une criture dune valeur numrique. Ces oprations
dentre/sortie ne sont pas gres directement au niveau du processeur mais dlgues
lmulateur.
A titre dexemple, voici un programme calculant une moyenne de 5 valeurs.
; exemple : calcul de moyenne
; dclaration des donnes
DATA
Somme
DW 0
Moyenne DW 0
Maximum DW 5
Notes
DW[5]
; instructions excuter
CODE
start:
MOV AX, 0
MOV BX, 0
loop:
LIRE Notes[BX]
ADD AX, Notes[BX]
INC BX
CMP BX, Maximum
JNE loop
MOV Somme, AX
DIV BX
MOV Moyenne, AX
ECRIRE Moyenne

Ce programme consiste demander lutilisateur dentrer cinq valeurs, qui vont tre
stockes dans le tableau Notes . La somme de ces valeurs est place dans la variable Somme .
Enfin, la moyenne est calcule par division entire, puis est stocke dans la variable Moyenne .
Ce rsultat est renvoye en sortie.
Ce court programme illustre le format gnral dun fichier programme. On notera lordre
des deux blocs introduits par DATA et CODE, ainsi que la dclaration de commentaires et
dtiquettes.

2. Modlisation en classes
Le langage de programmation retenu pour ce projet tant Java, la modlisation a t
effectue sous la forme dun arbre de classes, afin dutiliser au mieux les possibilits offertes dans
ce domaine par ce langage, telles que lhritage et le polymorphisme.
Chaque concept de lmulateur, comme celui de variable, de tableau ,de pile, de programme,
de processeur, de mmoire, a t modlis laide de classes. Lmulateur lui-mme est reprsent
sous la forme dune classe.

Page 6

/ 20

Emulation graphique du fonctionnement dun microprocesseur 8086

2.1. Modlisation des donnes gnrales

Larbre de classe utilis pour la reprsentation des donnes (variables, registres, constantes,
tiquettes) de base est montr ci-contre :
Afin de stocker diverses donnes comme des variables et des tableaux, nous avons besoin
dune classe Donnee permettant de stocker une valeur
numrique. Cette valeur est en lecture seule. Cette classe est
la base dautres classes permettant de stocker une tiquette (une
donne en lecture seule associe un nom), une variable ou un
registre (tous deux des donnes en lecture/criture et associes
un nom).
La classe Variable sert modliser une variable ou
un registre. Pour distinguer les deux utilisations, un champ
sorte a t introduit, ainsi que deux variables de classe
permettant de fixer la sorte (variable ou registre) dun objet de
la classe Variable lors de sa construction.
La construction dune variable se fait partir dun nom,
dune valeur initiale et dune sorte. La valeur transmise est
stocke dans le champ valeurInitiale qui peut tre recopi
dans le champ valeur (qui stocke la valeur courante) par un
appel la mthode reinitialiser .

sont modliss par une classe

indpendante des prcdentes en
dhritage. Voici le schmas
cette classe :
Un tableau est la donne
dun nombre fixe de cellules.
tant modifiable indpendamment
utilise la classe Variable pour
cellule. Le nom dune cellule est
du tableau suivi du numro de la cellule entre crochets.

Les
tableaux
Tableau
termes
descriptif
de
dun nom et
Chaque cellule
des autres, on
modliser
une
constitu du nom

La construction dun tableau se fait partir dun nom et dune taille (un nombre de cellules).
La classe ListeVariables mentionne ci-dessus est utilise afin de modliser une liste
contenant un nombre quelconque de variables. Il sagit en fait dune classe tendant la classe Vector
auquel on ajoute un attribut Nom accessible en lecture seule et fix lors de la construction.

Page 7

/ 20

Emulation graphique du fonctionnement dun microprocesseur 8086

2.2. Modlisation des donnes internes du processeur

Le processeur manipule 3 types de donnes internes que sont les registres, les flags et la pile.
Les registres sont modliss par la classe Variable , dcrite prcdemment. Les flags, quant
eux, sont modliss par une classe Flag , illustre sur la page suivante :
Une instance de la classe Flag permet de contenir
un boolen ainsi que les deux accesseurs. Notez quil ny a pas
de constructeur particulier pour cette classe puisque le
processeur est seul matre des valeurs des flags.

La pile est modlise par une classe Pile tendant la classe Stack de Java. La pile ne
contient que des instances de la classe Donnee : la valeur dune variable (ou dun registre) est
place dans la pile grce la mthode getDonnee de la classe Variable .
2.3. Modlisation de la mmoire

La mmoire est modlise par une classe dont

une instance est lie au processeur lors de sa
construction (classe CPU dcrite plus loin). Cette
instance est galement lie un programme, stock
dans un vecteur de chanes ( lignes ) et modlis
par la classe Programme dcrite plus loin.
La mmoire contient une liste de variables,
une liste de tableaux et une liste dtiquettes. Ces
trois lments sont initialiss lors dun appel
creerMemoire . Cette mthode effectue une lecture
dtaille des lignes du programme et traduit les
dclarations de variables, de tableaux et dtiquettes
en instances des 3 classes correspondantes. Chaque
instance est range dans une des 3 listes respectives.
La mmoire peut tre rinitialise aux valeurs de dpart spcifies dans le fichier source du
programme par un appel la mthode reinitialiser . Cette fonctionnalit vite une recration de
la mmoire partir des lignes du programme chaque nouvelle excution. Cette rinitialisation
sappuie sur la mthode reinitialiser de la classe Donnee ou de ses sous-classes.
Les trois mthodes obtenirVariable , obtenirTableau et obtenirEtiquette servent
pendant la traduction des lignes du programme en instructions excutables, pour dterminer si une
chane rencontre est une variable, un registre, un tableau ou une tiquette valide.
Enfin, les deux accesseurs getListeVariables et getListeTableaux permettent
linterface un accs direct en lecture/criture aux variables et aux tableaux.
2.4. Modlisation des instructions et des paramtres

Lors de la lecture dun fichier contenant un programme, chaque ligne est traduite en une
instruction excutable par le processeur. Celle-ci consiste en la donne dun code dinstruction pris
dans une liste de valeurs prdfinies, dun numro de ligne (qui fait office de numro dinstruction)
ainsi que dun boolen permettant de savoir si un point darrt (valable uniquement pendant
Page 8

/ 20

Emulation graphique du fonctionnement dun microprocesseur 8086

lexcution du programme) est plac sur cette instruction. Seules les vritables instructions ou les
tiquettes peuvent tre munies dun point darrt.
Les trois classes utilises pour modliser les
diffrentes sortes dinstructions (sans paramtre, unaire,
binaire) sont reprsentes ci-contre. Les instances de ces
classes sont cres au fur et mesure de la traduction dun
fichier source de programme et ce par la classe
Programme dcrite plus loin. Les instructions unaires
et binaires ont besoin respectivement dune (de deux)
instance(s) dune classe Param dcrite plus bas. Cette
classe abstraite est la classe de base de 4 sortes possibles
de paramtres.
Afin de dterminer le code dinstruction dune
ligne du programme, une liste de variable de classe a t
place dans la classe Instruction (52 codes possibles
lists en annexe).
Lors de lexcution dun programme, le
processeur utilisera directement ces instructions et les
excutera squentiellement.

Les paramtres sont modliss laide de cinq

classes, suivant leur sorte. Voici larbre de classes
correspondant :
La classe abstraite Param dfinit la structure de base dun paramtre gnrique, savoir
son type (choisi dans les classes descendantes parmi une liste de variables de classes) et son accs
possible ou non en criture.

Page 9

/ 20

Emulation graphique du fonctionnement dun microprocesseur 8086

Un paramtre peut tre :

-

une constante :
Dans ce cas le paramtre est reprsent par une instance de ParamConstante . La
valeur est stocke dans le champ valeur , accessible en lecture seule et fixe une fois
pour toutes lors de la cration de lobjet.

une variable (donc un registre ou une variable) :

Dans ce cas le paramtre est reprsent par une instance de ParamVariable . La
variable est rfrence par le champ var et est accessible en lecture. La possibilit
dcriture dpend de la valeur fixe pour le champ readOnly lors de la cration de
lobjet.

un tableau (index par un registre) :

Dans ce cas le paramtre est reprsent par une instance de ParamTableau . Le
tableau est rfrenc par le champ tab et le registre qui lindexe par le champ reg .
La cellule est accessible en lecture via les mthodes getDonnee (la seule utilisable
lorsque le paramtre est en lecture seule) et getElement (criture possible car cette
mthode retourne une instance de Variable). Lcriture se fait de manire indirecte en
obtenant la cellule par getElement et en modifiant sa valeur par sa mthode
setDonnee .

une tiquette :
Dans ce cas le paramtre est reprsent par une instance de ParamEtiquette .
Ltiquette est rfrence par le champ etiq . Une tiquette est accessible en lecture
seule. Le numro de ligne de ltiquette peut tre obtenu grce la mthode
getEtiquette .
2.5. Modlisation dun programme

La classe Programme est responsable du

stockage et de la traduction des instructions
excutables dun programme.
A chaque chargement dun nouveau
programme, une instance de la classe Memoire
est cre et construit la mmoire associe au
programme partir des lignes lues. Ensuite, une
instance de la classe Programme est cre en
passant en paramtre une rfrence au processeur et
une rfrence la mmoire prcdemment cre.
Une lecture dtaille des lignes du fichier source est
alors effectue afin den extraire les instructions sappuyant sur les donnes de la mmoire.
La lecture se fait ligne par ligne lors dun appel creerProgramme , et ce partir du
vecteur de chanes transmis en paramtre. Ce vecteur est stock dans le champ lignes pour
permettre son affichage ultrieur dans linterface. La lecture dune ligne est dlgue la mthode
traduireLigne , qui, grce la classe StringTokenizer de Java, dcoupe la ligne en mots
( tokens ). Suivant linstruction dtecte, il y aura ventuellement un ou deux appels la mthode
traduireParam afin de traduire les paramtres en instances dune des sous-classes de Param

Page 10

/ 20

Emulation graphique du fonctionnement dun microprocesseur 8086

La mthode getInstruction, laquelle on fournit un numro de ligne, renvoie linstruction

traduite partir de cette ligne du fichier source. Cette mthode est utilise par le processeur afin
dobtenir les instructions excuter.
2.6. Modlisation du microprocesseur

La classe CPU est le cur de lmulateur

puisquelle permet lexcution dinstructions partir
dune instance de la classe Programme et de la
classe Memoire . Lmulateur possde une
unique instance de cette classe. Les registres y sont
reprsents par un tableau dinstances de la classe
Variable et les flags par un tableau dinstances
de la classe Flag . La pile est galement stocke
comme uns instance de la classe Pile. Un ensemble
de mthodes est fourni afin daccder directement
chacun
de
ces
lments
( getPile ,
obtenirRegistre , obtenirFlag ) Ainsi, cette
classe est apte manipuler tous les lments du
programme et va donc se charger de lexcution de
ce dernier.
La mthode getIP permet lmulateur
de connatre le point dexcution en cours, ce qui est
utile lors dune excution en mode pas pas ou
lorsque celle-ci est suspendue suite la rencontre
dun point darrt.
Lexcution est contrle par les quatre
mthodes init , start , run et stop , qui permettent de lancer lexcution selon plusieurs
modes ( soit une excution intgrale du programme, soit une excution en pas pas ou encore une
excution jusqu une ligne dtermine par lutilisateur). Il est galement possible de relancer un
programme qui a t au pralable arrt. Le champ executionEnCours est mis vrai lorsquune
excution est lance et passe faux ds quelle est stoppe, mais reste vrai si elle nest que
suspendue.
La mthode init rinitialise les contenus des registres, des flags, de la pile. De plus, la
mmoire retrouve les valeurs qui lui avaient t affectes lors de sa cration, cest--dire les valeurs
extraites du fichier source du programme au moment de la lecture initiale. Le champ
executionEnCours est aussi rinitialis faux.
La mthode start lance une excution du programme partir de sa premire ligne. Pour
cela, elle rinitialise le processeur par appel la mthode init , fixe excutionEnCours vrai
et appelle la mthode run qui lance lexcution proprement dite. Le paramtre de cette mthode
prcise le mode dexcution et est directement transmis la mthode run .
La mthode run fonctionne suivant trois modes distincts :
Le premier est lexcution intgrale du programme. Dans ce cas, run excute le
programme instruction par instruction, par appel la mthode runLigne qui est
charge dexcuter une ligne. Les sauts et les appels de sous-programmes sont bien sr
Page 11 /

20

Emulation graphique du fonctionnement dun microprocesseur 8086

respects. Il ny a suspension de lexcution que pour les demandes dentres/sorties et

les points darrt.
Le deuxime est lexcution en mode pas pas. Ici, la mthode run excute une
seule et unique instruction non neutre (i.e. une vritable instruction du langage). Les
sauts et les appels sont aussi respects. Lintrt de ce mode est la possibilit pour
lutilisateur dexcuter le programme ligne par ligne depuis linterface, en vue de la
recherche de bugs ou pour comprendre le fonctionnement des instructions et leur
influence sur les registres, les donnes ou la pile.
Le troisime, mi-chemin entre les deux prcdents, permet de lancer lexcution
jusqu une ligne prcise en paramtre.
La mthode stop interrompt brutalement lexcution du programme, en fixant
executionEnCours faux. Ainsi, run ne peut plus tre appele et une excution ne pourra
tre reprise que par lintermdiaire de start .

3. Coordination du processeur, du programme et de la

mmoire
Afin de coordonner le processeur avec la mmoire et un programme charg, une classe
Machine a t cre. Elle contient une instance de la classe CPU et cre une instance de la
classe Programme , ainsi quune instance de la classe Memoire .
Son rle est double. Premirement, elle assure la communication entre dune part les classes
CPU , Programme et Memoire et dautre part le reste de lapplication. Cela permet de
slectionner les actions autorises sur le processeur depuis le reste de lapplication. Ainsi, une
grande partie des mthodes de la classe Machine enveloppe celle de la classe CPU portant le
mme nom. Deuximement, cette classe soccupe de la lecture du fichier contenant le programme
excuter et de la cration dun vecteur de chanes dont chaque lment est une ligne de ce fichier.
Cette fonction est assure par la mthode chargerFichier .
Le schma suivant montre les relations entre les classes CPU , Memoire ,
Programme , Machine et le reste de lapplication utilisant lmulateur : ce schma indique
clairement que toute communication entre dune part le processeur, la mmoire et le programme, et
dautre part le reste de lapplication passe par la machine.

Page 12

/ 20

Emulation graphique du fonctionnement dun microprocesseur 8086

IV. Lapplication Emul8086

Lutilisation de lmulateur en mode texte ntant pas la finalit du projet (cette utilisation
est cependant envisageable), nous avons dvelopp une application sappuyant sur deux lments
que sont notre mulateur et une interface graphique. Le type dapplication retenu est un dbogueur
en mode graphique, utilisant pleinement les possibilits de lmulateur. Il est possible dans cette
application de charger des programmes (un la fois), de les excuter et dinteragir avec la mmoire
ainsi quavec le processeur pendant lexcution.

1. Premier aperu de linterface graphique de lapplication

Cette interface se compose de 7 fentres ayant chacune une fonction bien prcise :
une fentre principale proposant le menu des fonctions possibles telles que
lexcution dun programme. Les six autres fentres ne sont utilisables quaprs le
chargement dun fichier ;
une fentre permettant de visualiser le code du programme excuter, les lignes
dotes dun point darrt et la prochaine instruction excuter ;
une fentre permettant de visualiser les variables du programme et leurs valeurs. Il
est possible de modifier la valeur dune variable pendant lexcution du programme ;
une fentre permettant de visualiser les tableaux du programme et leur contenu (liste
des cellules et de leurs valeurs respectives) ;
une fentre permettant de visualiser les contenus des registres et des flags du
processeur, galement modifiables en cours dexcution ;
une fentre permettant de visualiser ltat de la pile au point actuel dexcution ;
une fentre gardant la trace des entres/sorties effectues par les instructions LIRE et
ECRIRE.
Pour illustrer ces propos, voici une capture dcran montrant un programme en cours
dexcution :

Page 13

/ 20

Emulation graphique du fonctionnement dun microprocesseur 8086

Dans la capture dcran de la page prcdente, le surlignage en rouge dans la fentre de

Code Source signale un point darrt sur linstruction prsente sur cette ligne. Le surlignage en
bleu, quant lui, met en vidence la prochaine instruction qui sera excute.

2. Manuel de lutilisateur
La fentre principale, seule visible au dmarrage de lapplication, comporte quatre menus :
Fichier , Affichage , Excution et Aide . Voici un montage qui donne une description
rapide de laction effectue par chaque commande de menu.
Il est noter que seul le menu Fichier est actif au lancement de lapplication et quun
programme doit tre charg pour activer les menus Affichage et Excution , dans le but
dviter des incohrences telles que le dclenchement dune excution sans quun programme nait
t charg au pralable.

Pour charger un fichier, utilisez la commande Charger du menu fichier. Une bote de
dialogue souvre alors pour vous permettre den slectionner un. Il ny a aucune restriction sur les
noms de fichiers, mais celui qui est choisi doit contenir le code source dun programme, sans quoi
une erreur de lecture se produira, si le fichier est mal form du point vue syntaxique (instruction
inconnue, nombre ou type de paramtre incorrect, absence des mots cls CODE ou DATA). La
cohrence du code, ainsi que des donnes, ne sera vrifie quau cours de lexcution. Une fois le
fichier charg, son contenu apparat dans la fentre de Code Source et les autres fentres
souvrent en vue de lexcution du programme.

Page 14

/ 20

Emulation graphique du fonctionnement dun microprocesseur 8086

Il est possible dexcuter un programme de diverses manires. La manire la plus simple

consiste lancer une excution intgrale, par le raccourci clavier F9 depuis la fentre de Code
Source . Ce mode nest pas interactif, except pour les demandes dentres de donnes ou les
points darrt si le programme en contient.
Il existe deux manires de contrler plus finement lexcution du programme. La premire
permet son excution non interactive jusqu une ligne du code choisie par lutilisateur, et sa
suspension lorsque cette ligne est atteinte. Pour ce faire, il suffit de se placer sur la ligne en question
et dappuyer sur la touche F4. Cette fonctionnalit permet de savoir si une instruction est ou non
excute, ou de contrler facilement lexcution dune boucle.
La seconde, appele mode pas pas , permet lexcution la plus dtaille, savoir
instruction par instruction. Pour lutiliser, employez le raccourci clavier F7. A chaque appui sur
cette touche, une seule et unique instruction est excute. Il sagit du mode le plus pratique pour
bien visualiser les modifications des registres, des flags, de la pile, des variables et des tableaux,
suite lexcution de chaque ligne du programme. En outre, il permet de visualiser lenchanement
des sauts et des appels de sous-programmes.
Les diffrents modes dexcution peuvent tre utiliss conjointement pour, par exemple
dtailler lexcution dune petite partie dun programme.
Un autre moyen dobtenir plus de dtails sur lexcution dun programme est lutilisation de
points darrt. Un point darrt pos sur une instruction demande ce que lexcution soit
temporairement suspendue chaque fois cette instruction est atteinte. Pour fixer un point darrt sur
une ligne, opration qui nest possible que sur une vraie instruction ou une tiquette, slectionnez-la
et utilisez le raccourci clavier F5. Sil est permis de poser un point darrt sur cette ligne, elle sera
surligne en rouge. De la mme manire, il est possible de supprimer un point darrt existant, en le
slectionnant et en appuyant sur F5. A lexcution, lorsquun point darrt est rencontr,
lapplication rend la main lutilisateur, qui peut au choix poursuivre lexcution par la touche F9
ou utiliser lun des deux autres modes (excution jusqu une ligne prcise ou pas pas).
A tout moment, il est possible dinterrompre lexcution, grce lutilisation de la
commande Arrter , accessible depuis le raccourci clavier Contrle + F2. On peut galement
relancer lexcution depuis le dbut du programme en utilisant la commande Relancer , avec le
raccourci Ctrl + F9.
Lorsque lexcution est suspendue (et non pas termine), cest dire lorsque la fentre fait
apparatre un point dexcution, les contenus des variables, des tableaux, des flags et des registres
autoriss (AX, BX, CX et DX uniquement) sont modifiables volont. Pour cela, utilisez la zone
ddition correspondante llment dont on veut modifier la valeur (qui doit imprativement tre
comprise entre 0 et 65535). Saisissez la nouvelle valeur, puis appuyez sur entre pour confirmer la
modification. Si la valeur saisie est errone, un message derreur saffiche et la modification nest
pas prise en compte. Notez quil est impossible depuis lapplication de rajouter ou de supprimer une
variable ou un tableau.
Pour ce qui est des flags, il suffit de cocher ou de dcocher la case correspondante pour
changer leur tat (la case coche signifie que le flag est vrai ).
Certains programmes peuvent faire intervenir des entres/sorties, au moyen des instructions
et ECRIRE. Le rsultat dune instruction ECRIRE est laffichage dun message dans la fentre
d Entres/Sorties , comportant la valeur afficher ainsi que sa provenance. Linstruction LIRE,
quant elle, provoque laffichage dune bote de dialogue demandant dentrer une valeur pour
llment donn en paramtre de la dite instruction, dont un exemple est montr ci-contre.
LIRE

Page 15

/ 20

Emulation graphique du fonctionnement dun microprocesseur 8086

Une fois la valeur saisie, lexcution continue et une trace de cette opration apparat dans
la fentre d Entres/Sortie . Il est noter, au
risque de se rpter, que les valeurs saisir doivent
toujours tre comprises entre 0 et 65535. Si tel nest
pas le cas, la demande de valeur de renouvele
jusqu lobtention dune valeur correcte.
Lutilisateur peut aussi choisir dannuler la saisie de
la valeur. Dans ce cas, lexcution est interrompue.

3. Fonctionnement interne de lapplication

Lapplication se compose dune classe principale, appele Emul8086 qui gre la fois la
partie interface graphique et la partie mulateur. Le dtail du fonctionnement de lmulateur a dj
t abord dans ce rapport. Nous allons donc nous limiter dcrire le fonctionnement de linterface
graphique, ainsi que la communication entre linterface graphique et lmulateur.
La classe Machine , qui dans un premier temps tait indpendante, a t adapte de faon
permettre son pilotage par lapplication. Au dmarrage de celle-ci, une instance de la classe
Emul8086 est cre. Dornavant, le terme application dsignera cette instance. Elle cre son
tour une instance de la classe Machine et met en place la connexion avec lmulateur. De plus,
linterface graphique est initialise.
Linterface graphique fonctionne laide de sept classes, dfinissant chacune lapparence et
le fonctionnement dune des fentres de linterface (prcdemment dcrites). Voici, une table de
correspondance entre le nom de la fentre et le nom de la classe qui lui est associe :
Nom de la fentre
Principale
Variables
Tableaux
Registres et Flags
Code Source
Pile
Entres/ Sorties

Nom de la classe
TFenPrinc
TFenEditeurVar
TFenEditeurTab
TFenEditeurReg
TFenCodeSource
TFenEditeurPile
TFenEntreeSortie

Lors du chargement dun fichier, depuis le menu de la fentre principale, lapplication reoit
lordre de charger le fichier indiqu par lutilisateur. Ce chargement seffectue en trois tapes. La
premire consiste vider linterface, au cas o un autre programme aurait t charg
prcdemment. La deuxime transfre cette requte lmulateur (i.e. linstance de la classe
Machine ). La troisime met jour linterface partir des donnes traduites et mises
disposition par lmulateur. Cette remise jour de linterface comprend, entre autre, ltablissement
dune liaison entre dune part les diffrentes fentres de linterface et dautre part les donnes
rendues disponibles par lmulateur.
Les diverses commandes dexcution disponibles depuis linterface graphique sont
transmises lapplication par la fentre principale ou la fentre de Code Source (via les raccourcis
clavier mentionns prcdemment). Lapplication transmet, son tour, ces commandes
lmulateur, qui effectue leur traitement et retourne les rsultats. Ces derniers sont alors rcuprs
par lapplication, qui met jour linterface graphique en rponse aux changements de donnes
fournis par lmulateur, savoir les valeurs des variables, des registres, des flags, de la pile, du
point dexcution et des cellules des tableaux. Grce ce systme, il y a indpendance de linterface
graphique vis vis de lmulateur et toute communication entre ces deux sous-ensembles de
Page 16

/ 20

Emulation graphique du fonctionnement dun microprocesseur 8086

lapplication passe obligatoirement par cette dernire. Il y a donc un change permanent

dinformation entre lmulateur et linterface, comme indiqu sur le schma suivant :
Lutilisateur peut galement interagir avec lmulateur, en modifiant des variables, des
registres, des flags et en basculant des points darrt.
Lorsque lutilisateur valide une modification de la valeur dune donne depuis linterface,

cette demande est prise en compte directement dans linstance de la classe Variable conservant
la valeur de cette donne. Si la valeur saisie est incorrecte, la valeur initiale est rtablie dans la zone
ddition de la donne. Pour les flags, la modification est prise en compte directement par linstance
correspondante de la classe Flag .
Le fait de basculer un point darrt depuis la fentre de code source transmet la requte
lapplication, qui la transmet son tour lmulateur. Ce dernier accepte le point darrt si la ligne
sur laquelle il doit tre plac contient une instruction ou une tiquette. Lmulateur refuse de placer
un point darrt sur toute autre ligne du fichier source.
Lors de lexcution dune instruction dentre ( LIRE ) ou de sortie ( ECRIRE ), il y a
galement un va-et-vient entre linterface graphique et lmulateur.
Lors dune lecture, lmulateur demande la saisie dune valeur lapplication. Celleci transmet la demande la fentre grant les entres/sorties, qui ouvre une boite de
dialogue qui spcifie llment pour lequel on dsire une valeur et qui invite
lutilisateur entrer celle-ci. Le fait dannuler cette saisie stoppe lexcution. Si la
saisie est valide, le rsultat est retourn lapplication qui le transmet son tour
lmulateur. Celui-ci peut alors poursuivre lexcution aprs avoir mmoris cette
nouvelle valeur.
Lors dune criture, lmulateur transmet lordre de sortie lapplication qui
transmet cet ordre la fentre grant les entres/sorties. Cette dernire effectue
simplement un affichage du nom de llment afficher ainsi que de sa valeur.

Page 17

/ 20

Emulation graphique du fonctionnement dun microprocesseur 8086

V. Conclusion
Lapprentissage de la programmation en assembleur tant une tche ardue pour un
programmeur, nous avons tent, au travers de cette application, de la lui faciliter. Son interface
conviviale, mettant laccent sur les bases en laissant les dtails trop techniques de cot, a pour
ambition daider le dbutant mieux apprhender le fonctionnement de lassembleur.
Du fait de linteractivit existante pendant lexcution dun programme, il est
particulirement ais de comprendre les effets de chaque instruction non seulement sur lordre
dexcution de celles-ci, mais aussi sur les donnes manipules (mmoire, pile, registres et flags).
En ce qui nous concerne, ce projet a t loccasion de dvelopper une vritable application
crite en Java, et ce en utilisant ses capacits en terme de gestion dinterfaces graphiques. Le fait de
programmer dans un langage objets nous a permis dapprendre modliser entirement un
problme laide dune hirarchie de classes. Dautre part, le fait que le stage soit en rapport troit
avec la programmation en assembleur et le fonctionnement dun microprocesseur nous a apport
une meilleure matrise de ces deux notions.

Page 18

/ 20

Emulation graphique du fonctionnement dun microprocesseur 8086

Bibliographie
James W.COFFRON, 8086/8088 fonctionnement et programmation , d. Micro Passion
Collection, 1983.
Steven GUTZ, Up to speed with Swing user interfaces with Java foundation classes , d.
Manning, 1998.
Mark C.CHAN, Steven W.GRIFFITH, Anthony F.IASI, 1001 Java Programmers Tips ,
d. Jamsa Press, 1997.
Sun, Java 2 Software Development Kit SE v1.3 :
http://java.sun.com/j2se/1.3/docs/index.html.
Sun, The Java Tutorial :
http://java.sun.com/docs/books/tutorial/index.html.

Page 19

/ 20

Emulation graphique du fonctionnement dun microprocesseur 8086

Annexe A : Liste des codes doprations

Cette liste est extraite du fichier Instruction.java et reprend simplement les dclarations
de variables de classe.
public
public
public
public
public
public
public
public
public
public
public
public
public
public
public
public
public
public
public
public
public
public
public
public
public
public
public
public
public
public
public
public
public
public
public
public
public
public
public
public
public
public
public
public
public
public
public
public
public
public
public
public

static
static
static
static
static
static
static
static
static
static
static
static
static
static
static
static
static
static
static
static
static
static
static
static
static
static
static
static
static
static
static
static
static
static
static
static
static
static
static
static
static
static
static
static
static
static
static
static
static
static
static
static

final
final
final
final
final
final
final
final
final
final
final
final
final
final
final
final
final
final
final
final
final
final
final
final
final
final
final
final
final
final
final
final
final
final
final
final
final
final
final
final
final
final
final
final
final
final
final
final
final
final
final
final

int
int
int
int
int
int
int
int
int
int
int
int
int
int
int
int
int
int
int
int
int
int
int
int
int
int
int
int
int
int
int
int
int
int
int
int
int
int
int
int
int
int
int
int
int
int
int
int
int
int
int
int

OPER_NOP = 0;
OPER_PUSH_REG = 1;
OPER_POP_REG = 2;
OPER_MOV_REG_REG = 3;
OPER_MOV_REG_VAR = 4;
OPER_MOV_VAR_REG = 5;
OPER_MOV_REG_CST = 6;
OPER_MOV_REG_TAB = 7;
OPER_MOV_TAB_REG = 8;
OPER_CALL_ETIQ = 9;
OPER_RET = 10;
OPER_ADD_REG_CST = 11;
OPER_ADD_REG_REG = 12;
OPER_ADD_REG_VAR = 13;
OPER_ADD_REG_TAB = 14;
OPER_SUB_REG_CST = 15;
OPER_SUB_REG_REG = 16;
OPER_SUB_REG_VAR = 17;
OPER_SUB_REG_TAB = 18;
OPER_MUL_CST = 19;
OPER_MUL_REG = 20;
OPER_MUL_VAR = 21;
OPER_MUL_TAB = 22;
OPER_DIV_CST = 23;
OPER_DIV_REG = 24;
OPER_DIV_VAR = 25;
OPER_DIV_TAB = 26;
OPER_CMP_REG_CST = 27;
OPER_CMP_REG_REG = 28;
OPER_CMP_REG_VAR = 29;
OPER_CMP_REG_TAB = 30;
OPER_JUMP_ETIQ = 31;
OPER_JG_ETIQ = 32;
OPER_JGE_ETIQ = 33;
OPER_JE_ETIQ = 34;
OPER_JNE_ETIQ = 35;
OPER_JL_ETIQ = 36;
OPER_JLE_ETIQ = 37;
OPER_INC_REG = 38;
OPER_DEC_REG = 39;
OPER_NOT_REG = 40;
OPER_AND_REG_REG = 41;
OPER_OR_REG_REG = 42;
OPER_XCHG_REG_REG = 43;
OPER_LIRE_REG = 44;
OPER_LIRE_VAR = 45;
OPER_LIRE_TAB = 46;
OPER_ECRIRE_CST = 47;
OPER_ECRIRE_REG = 48;
OPER_ECRIRE_VAR = 49;
OPER_ECRIRE_TAB = 50;
OPER_ETIQ = 51;

Page 20

/ 20

Emulation graphique du fonctionnement dun microprocesseur 8086

Page 21

/ 20

Table des matires

I. PRSENTATION DU SUJET.......................................................................................................1
II. RAPPELS SUR LE MICROPROCESSEUR INTEL 8086.......................................................2
III. MODLISATION DE LMULATEUR...................................................................................4
1. Caractristiques gnrales............................................................................................................4
2. Modlisation en classes................................................................................................................6
2.1. Modlisation des donnes gnrales....................................................................................7
2.2. Modlisation des donnes internes du processeur................................................................8
2.3. Modlisation de la mmoire..................................................................................................8
2.4. Modlisation des instructions et des paramtres..................................................................8
2.5. Modlisation dun programme............................................................................................10
2.6. Modlisation du microprocesseur.......................................................................................11
3. Coordination du processeur, du programme et de la mmoire...................................................12
IV. LAPPLICATION EMUL8086..................................................................................................13
1. Premier aperu de linterface graphique de lapplication..........................................................13
2. Manuel de lutilisateur................................................................................................................14
3. Fonctionnement interne de lapplication....................................................................................16
V. CONCLUSION............................................................................................................................18
BIBLIOGRAPHIE...........................................................................................................................19
ANNEXE A : LISTE DES CODES DOPRATIONS.................................................................20

Laboratoire dEtudes et de Recherche en Informatique dAngers

LERIA

Emulation graphique
du fonctionnement
dun microprocesseur
8086
Frdric BEAULIEU
Yan LE CAM

Responsable du projet : Mr. Jean-Michel RICHER

2000-2001

Universit dAngers

Dpartement Informatique