Systèmes à microprocesseurs - TP de simulation N°1

Systèmes à Microprocesseurs
TP de simulation N°1 : Emulateur de P 80x86 : emu8086

I. Objectifs
• Prise en main de l’émulateur emu8086.
• Etude du langage assembleur du P 8086
• Développer des programmes simples dans l’environnement de l’émulateur emu8086

II. Matériel Utilisé

• Micro-ordinateur IBM et compatible muni d’un μP80x86.
• Emulateur de P 8086 : emu8086

III. Introduction
Dans un premier temps, pour simplifier l’apprentissage de l’assembleur x86, nous allons travailler sur
un émulateur logiciel qui simule un processeur 8086. L’utilisation de cette émulation n’est pas
obligatoire car nos programmes, écrits en assembleur 8086, fonctionne normalement sur un
processeur moderne comme l’Intel core i7, ou l’AMD Phenom.

Cependant, comme vous le verrez tout au long de ces TPs, l’émulateur nous fourni un environnement
avancé pour l’apprentissage des mécanismes et du fonctionnement du processeur.

Emu8086 se présente dans un premier temps comme un éditeur de texte classique, avec le support
d’une colorisation syntaxique du code assembleur (mode éditeur).

Le fichier squelette.asm contient la déclaration d’un segment de pile de 512 octets, la déclaration
d’un segment de données vide ainsi que la déclaration d’un segment de code. Dans ce dernier, on
retrouve la directive ASSUME permettant d’initialiser les trois registres de segments CS, DS et SS.

On trouve aussi une zone de déclaration de fonctions publiques, une zone de déclaration de fonctions
externes une zone de déclaration de fonctions locales, puis du code assembleur.
Par M. JAROU Page |1
 Systèmes à microprocesseurs - TP de simulation N°1

Ce code débute par l’étiquette debut, puis on retrouve l’initialisation des segments de données et de
pile (cette initialisation est doublée pour des raisons de compatibilité). Un espace réservé à l’écriture
de vos programmes suit ces éléments. Enfin, l’étiquette fin indique (informellement) la fin du
programme. Les deux lignes suivantes correspondent à l’appel standards de l’interruption DOS dont
le rôle est de terminer d’un programme de manière normal (libération de la mémoire, …). Ensuite on
trouve la fin du segment de code puis celle du programme.

Pensez lorsque vous écrirez un programme à bien partir de ce fichier squelette en le sauvegardant
sous un autre nom avant de le modifier.

IV. Activités pratiques

Activité pratique 1 : Prise en main d’emu8086

1.1 Squelette des programmes sources
1. Créez un fichier ex1.asm identique au fichier squelette.asm donnée ci-dessous. Compilez et
exécutez le programme (bouton RUN). Validez la fin de l’exécution avec OK.

STACK SEGMENT STACK

DW 256 DUP(0)
base:
STACK ENDS

DATA SEGMENT
; ici on declare les variable
DATA ENDS

CODE SEGMENT
ASSUME CS:CODE, DS:DATA, SS:STACK

; ici on declare les fonctions publiques

; ici on declare les fonctions externes

; ici on declare les fonctions locales

; on precise a l'aide d'un commantaire
; son nom, ses entrees et ses sorties

; Procedure: name
; Entree: ...
; Sortie: ...

debut:
MOV AX, DATA
MOV DS, AX

MOV AX, STACK

MOV SS, AX
MOV SP, base

; ici on ecrit le corps du programme

fin:
MOV AH, 4CH
INT 21H

Par M. JAROU Page |2

 Systèmes à microprocesseurs - TP de simulation N°1

CODE ENDS
END debut

Fenêtre de l’éditeur de l’émulateur emu8086

Deux nouvelles fenêtres viennent de s’ouvrir, il s’agit du mode exécution de l’émulateur. La fenêtre «
original source code » contient le code tel que vous l’avez écrit. La ligne surlignée en jaune est la
prochaine instruction qui va être exécutée. Comme on le verra plus loin dans ce TP, il est possible
d’interagir avec ce code en cliquant dessus. La zone mémoire de la fenêtre « emulator : » change
pour correspondra à la partie sélectionnée par le click.

Fenêtres de travail de l’émulateur emu8086.

Par M. JAROU Page |3

 Systèmes à microprocesseurs - TP de simulation N°1

La fenêtre « emulator : » contient 4 zones que nous allons détailler ci-dessous :

Zone 1: Les boutons vont nous permettre d’exécuter notre programme soit automatiquement soit Pas
à Pas, avec la possibilité de revenir en arrière et de régler un délai d’attente entre chaque instruction.

2. Réinitialisez votre programme (reload) puis exécutez-le pas à pas (single step et back step)
jusqu'à la fin. Faites une nouvelle réinitialisation, réglez le délai sur 400 ms et faites une
exécution normale (run)

Zone 2: La zone 2 contient une représentation des registres, et permet de visualiser leur valeur
hexadécimale tout au long de l’exécution de votre programme. Il est possible de modifier la valeur
des registres (simple click) ou d’ouvrir une vue détaillée du registre (double click).

3. Exécutez votre programme et observez les valeurs des registres durant l’exécution. Vous porterez
une attention particulière au registre IP.
4. Après l’exécution de la première instruction, quelle est la valeur décimale du registre AX ?
Quelle est l’adresse de l’étiquette Base dans le segment de Pile ? Et quelle est son adresse dans
la mémoire ?

Zone 3: La zone 3 représente la mémoire octet par octet. Sur une ligne, on retrouve l’adresse
mémoire sur 20 bits, la valeur de l’octet en hexadécimale, en décimale et sa représentation en ASCII.

5. Pourquoi l’adresse est elle représenté sur 20 bits ? Quel est le code instruction en langage
machine qui correspond à l’instruction MOV DS, AX ?

Zone 4: La zone 4 contient le code de votre programme une fois les traductions d’adresses terminées.
Il n’y a plus aucune étiquette ni nom de variable. Il s’agit du code machine réellement exécuté.

6. Quel est le code réellement exécuté correspondant à votre programme (entre l’étiquette debut et
la fin du segment de code)? Quelle serait la première instruction (en code réellement exécuté) si
la pile avait une taille de 1024 octets ?

1.2 Déclarations des données

Nous allons maintenant nous intéresser au segment de données et surtout la création de variables.

1. En partant du squelette que vous sauvegarderez sous le nom ex1.asm créez dix variables de type
octet, nommées b0 à b9 et contenant les valeurs décimales 1, 255, -1, ‘e’, les valeurs
hexadécimale 32, FF et les valeurs binaires 1, 11111111.
2. Créez les mêmes variables de type mot que vous nommerez d0, d1, …
3. Créez ensuite un tableau de 10 octets nommé tb qui contient lui aussi ces valeurs. Faites de même
avec un tableau de 10 mots (td).
4. Créez ensuite un tableau de 152 octets contenant la valeur décimale 111 et un tableau de 150
mots contenant la valeur décimale 43981.
5. Compilez et exécutez votre programme en mode pas à pas. En cliquant sur le nom des variables
(fenêtre original source code) vérifiez les valeurs en mémoire.
6. Que dire des valeurs signées ? Et des caractères ? Quel est la différence entre une variable de
type mot et de type octet ? Quel est la différence entre un tableau et une suite de variables ?
Avez-vous remarqué autre chose ? Quelle est la taille du segment de données ?

Par M. JAROU Page |4

 Systèmes à microprocesseurs - TP de simulation N°1

Activité pratique 2 : Etude et test de programme simple

2.1 Etude de programme simple
1. Regardez attentivement ce programme et répondez aux questions suivantes sans compiler ce
programme.

PILE SEGMENT STACK

DW 256 DUP(?)
Base:
PILE ENDS

DATA SEGMENT
N1 DW 5
N2 DW 3
N3 DW 3 DUP(?)
N4 DB ?
DATA ENDS

CODE SEGMENT
ASSUME CS:CODE, DS:DATA, SS:PILE

main:
MOV AX,DATA ; Initialisation du segment de données
MOV DS,AX
MOV AX,PILE
MOV SS,AX ; Initialisation du segment de pile
MOV SP,Base ; Initialise la pile à vide
MOV AX,N1
CMP AX,N2
JE etiq
MOV N4,0
JMP fin
Etiq:
MOV N4,1
fin:
MOV AH,4CH ; Les 2 lignes nécessaires pour la fin du programme
INT 21H ;
CODE ENDS
END main

2. Que fait ce programme ? Quelle sera la valeur de N4 à la fin de l’exécution du programme ? Les
valeurs de N1, N2, N3 sont-elles modifiées ? La pile est composée de combien d’octets ?
3. Combien y a-t-il de variables créées dans le segment de données ? Quelle taille occupent-elles ?
Que se passe-t-il si vous enlevez l’instruction JMP fin ? Quelle sera la valeur de N4 dans ce cas-
là à la fin de l’exécution du programme ?

Nous allons voir que certaines options du menu view peuvent être pratiques. Voyons rapidement les
principales options disponibles (certaines sont accessible directement par des boutons situés sous la
zone 3) :

• Stack: affiche la pile.

• Variable: affiche la liste des variables et leurs valeurs.
• Memory: affiche une partie de la mémoire. La visualisation en mode table permet plus facilement
de se repérer.
• Flag: affiche la valeur des différents drapeaux.
• Ascii code: affiche une table ascii au cas où vous auriez oublié la votre.
Par M. JAROU Page |5
 Systèmes à microprocesseurs - TP de simulation N°1

Pour en finir avec les menus, dans math, vous trouverez deux outils pour vous aider dans les
conversions de base et les calculs.

4. Complétez le fichier squelette.asm pour qu’il corresponde au programme ci-dessus. Attention, à

ne pas modifier inutilement le fichier squelette. Le résultat sera sauvegardé dans le fichier
ex2.asm. Exécutez pas à pas ce programme et vérifier les réponses aux questions.

2.2 Test de programmes simples

1. Somme de 2 variables de type mot
Ecrivez un programme ex2a.asm qui fait la somme de 2 variables de type mot (précédemment
déclarées) et qui sauvegarde le résultat dans une troisième variable de type mot. Faites des tests
avec des valeurs positives et négatives.
2. Somme de 2 variables de type octet
Ecrivez un programme ex2b.asm qui fait la somme de 2 variables de type octet (précédemment déclarées)
et qui sauvegarde le résultat dans une troisième variable de type mot.
3. Somme de 2 variables
Ecrivez un programme ex2c.asm qui fait la somme de 2 variables de type mot (précédemment
déclarées) et qui sauvegarde le résultat dans une variable de type octet si cela est possible ou
dans une variable de type mot si le résultat ne tient pas dans une variable de type octet. Faire des
tests avec les valeurs négatives.

Par M. JAROU Page |6

 Systèmes à microprocesseurs - TP de simulation N°1

Activité pratique 3 : Programme avec Entrées/Sorties

Pour la gestion des entrées (lecture de texte au clavier) ou les sorties (affichage à l’écran), nous allons
utiliser les interruptions DOS.

En assembleur, on appelle/exécute une interruption à l’aide de la commande INT. Cette instruction à

un seul paramètre qui est le numéro de l’interruption. La valeur de ce numéro étant codé sur 8 bit,
seul 255 interruptions différentes sont possibles (noté de 0 à FFh). Par exemple, INT 8 appelle
l’interruption numéro 8.

Pour ne pas être limité à cette valeur, chaque interruption va également lire une valeur dans un
registre ( AH) qui lui indique quelle sous interruption est réellement appelé. Par exemple « « AH, 01h
/ INT 21h » permet de lire un caractère au clavier alors que « AH, 02h / INT 21h »permet d’afficher
un caractère à l’écran.

3.1 Interruptions DOS

Regardons maintenant quelques exemples d’interruption DOS :

- Lecture d’un caractère au clavier

MOV AH, 01H

INT 21H

Cette fonction permet de lire un caractère sur l’entrée standard. Ce caractère est récupéré sous la
forme de son code ASCII dans AL.
• Entrée : AH = 01h
• Sortie : AL = contient le code ASCII du caractère saisi au clavier

- Affichage d’un caractère à l’écran

MOV DL, ’A’

MOV AH, 02H
INT 21H

Cette fonction permet de sortir (afficher) un caractère sur la sortie standard. Ce caractère doit être
stocké sous la forme de son code ASCII dans DL.
• Entrée : AH = 02h
• Sortie : DL = Code ASCII du caractère à afficher

- Affichage d’une chaine de caractère

MOV DL, offset MaChaine

MOV AH, 09H
INT 21H

Cette fonction permet d’afficher une chaîne de caractères sur la sortie standard. Cette chaîne doit être
stockée sous la forme d'une séquence d'octets correspondant aux codes ASCII des caractères
composant la chaîne. La fin de la chaîne de caractères doit être signalée à l'aide du caractère '$'.
• Entrée : AH = 09h
• Sortie : DS = Adresse de segment de la chaîne de caractères
DX = Adresse d'offset de la chaîne de caractères

Par M. JAROU Page |7

 Systèmes à microprocesseurs - TP de simulation N°1

3.3 Test de programme avec Entrées/Sorties

1. Ecrivez un programme ex3a.asm qui fait la somme de 2 valeurs (entre 0 et 4) qui seront lues au
clavier. Ensuite vous afficherez le résultat (entre 0 et 8) à l’écran.
2. Ecrivez un programme ex3b.asm qui fait la somme de 2 valeurs (entre 0 et 9) qui seront lues au
clavier. Un message d’invite sera affiché avant la lecture des valeurs au clavier. Ensuite vous
afficherez le résultat (entre 0 et 18) à l’écran avec un message clair.
3. Ecrivez un programme ex3c.asm qui est une extension du programme précédent dans lequel vous
gérerez la lecture clavier d’un nombre sur 8 bits (entre 0 et 255) et dont le résultat pourra être
entre 0 et 510.

Activité pratique 4 : Branchement et boucles

4.1 Etude des boucles
Convertissez les algorithmes ci-dessous en assembleur

 IF THEN ELSE  La boucle FOR  La boucle WHILE

If (AX>BX) { BX = 5 AX = 0
Max = AX AX = 2 CX = 0
} For (CX=0 ; CX<BX ; CX++){ while ( AX < 10){
else{ AX += CX CX += 2*AX
Max = BX } AX++
} }

 La boucle REPEAT  Le test SWITCH

BX = 5 Switch (AX) {
Repeat 10 { case 1: BX =1 ; break;
BX += BX case 2: BX = 5 ; break ;
} case 3: BX = 10; break;
default: BX = 0;
}

4.2 Etude des branchements en assembleur

1. Complétez le programme ex4..asm qui se trouve dans le répertoire TP4 pour qu’il respecte les
commentaires.
2. Quel est la valeur de Re obtenue ?
3. Sans modifier le code de votre programme, juste en changeant les valeurs de N1, N2, N3, N4,
obtenez 11 comme valeur finale pour Re.

PILE SEGMENT STACK

DW 256 DUP(?)
base:
PILE ENDS

DATA SEGMENT
N1 DW 5
N2 DW 3
N3 DW -1
N4 DW 5
Re DB 0
DATA ENDS

CODE SEGMENT
ASSUME CS:CODE, DS:DATA, SS:PILE
main:

Par M. JAROU Page |8

 Systèmes à microprocesseurs - TP de simulation N°1

MOV AX,DATA ; initialisation du segment de donnees

MOV DS,AX

MOV AX,PILE
MOV SS,AX ; initialisation du segment de pile
MOV SP,Base ; initialise la pile a vide

MOV AX, N1
MOV BX, N2
MOV CX, N3
MOV DX, N4

CMP AX, DX
; si ax=dx alors on va a l'etiquette egaux
MOV Re, 2
egaux:
ADD Re, 5
CMP BX, CX
; si bx<cx alors on va a l'etiquette inf
ADD Re, 2
JMP et1
inf:
SUB Re, 2
et1:
CMP BX, 24
; si bx>24 alors on va a l'etiquette sup
ADD Re, 255
sup:
INC AX
CMP AX, DX
; si ax=dx alors on va a l'etiquette egaux2
SUB Re, 5
JMP fin
egaux2:
ADD Re, 5
CMP CX, 26
; si cx<=26 alors on va a l'etiquette infeg
DEC Re
infeg:
ADD Re, 1
CMP N1, 0xFFFDh
; si N1=FFFDh alors on va a l'etiquette egal
SUB Re, 10
egal:
CMP N4,0
; si N4<0 alors on va a l'etiquette fin
ADD Re, 3
fin:
MOV AH,4CH ; Les 2 lignes necessaires pour la fin du programme
INT 21H
CODE ENDS
END main

Par M. JAROU Page |9

 Systèmes à microprocesseurs - TP de simulation N°1

4.3 Les instructions de branchement

Soit un ensemble de programmes ayant le même segment de données.

DATA SEGMENT
Tab1 DB 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16
Tab2 DB 16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1
Tab3 DB 16,13,10,8,1,15,3,2,5,4,8,9,7,14,11,12
resTab1 DB 16 DUP (0)
resTab2 DB 16 DUP (0)
resTab3 DB 16 DUP (0)
resTab4 DB 48 DUP (0)
DATA ENDS

Ecrivez les programmes suivants :

1. Le tableau resTab1 contient le tableau Tab1 ou l’on a ajouté 1 aux nombres impaires (idem pour
resTab2 et resTab3)

2. Le tableau resTab1 contient le tableau Tab1 ou l’on a enlevé 10 aux nombres impaires (idem
pour resTab2 et resTab3) et resTab4 contient les tableaux resTab3 puis resTab2 et enfin resTab1
en sens inverse (de la fin au début). Si un nombre de resTab1, resTab2 ou resTa3 est négatif, on
stockera 0 à sa place.

3. Le tableau resTab1 contient le tableau Tab1 ou l’on a ajouté 120 aux nombres paires (idem pour
resTab2 et resTab3) et resTab4 contient les tableaux resTab3 puis resTab2 et enfin resTab1 en
sens inverse (du début à la fin). Si un nombre de resTab1, resTab2 ou resTa3 est supérieur à 127,
on stockera 127 à sa place.

Activité pratique 5 : Manipulation de la pile

5.1 Recherche de minimum et de maximum
Ecrivez un programme qui demande à l’utilisateur de saisir 5 entiers compris entre 0 et 9 et qui
affiche la somme de ces entiers ainsi que la valeur minimum et maximum.

N.B
• vous n’avez pas le droit d’utiliser des variables (sauf pour contenir du texte à afficher),
• vous devrez structurer votre programme en 3 étapes successives : Lecture des valeurs, calcul de la
somme, recherche du minimum et du maximum et vous afficherez les résultats comme la montre la
figure ci-dessous après chaque étape.

Par M. JAROU P a g e | 10
 Systèmes à microprocesseurs - TP de simulation N°1

5.2 Calcul de la moyenne olympique

Ecrivez un programme qui demande à l’utilisateur de saisir 10 entiers compris entre 00 et 99 et qui
affiche la moyenne.

N.B.
• vous n’avez pas le droit d’utiliser des variables (sauf pour contenir du texte à afficher),
• vous devrez structurer votre programme en 2 étapes successives : Lecture des valeurs, calcul de la
moyenne et vous afficherez les résultats comme dans l’exercice 2.

5.3 Calcul de la moyenne olympique

Ecrivez un programme qui demande à l’utilisateur de saisir 10 entiers compris entre 00 et 99 et qui
affiche la moyenne olympique (moyenne calculée sans la valeur maximale ni la valeur minimale).

N.B.
• vous n’avez pas le droit d’utiliser des variables (sauf pour contenir du texte à afficher),
• vous devrez structurer votre programme en 3 étapes successives : Lecture des valeurs, recherche du
minimum et du maximum, calcul de la moyenne olympique et vous afficherez les résultats comme
dans l’exercice 2.

Par M. JAROU P a g e | 11
 Systèmes à microprocesseurs - TP de simulation N°1

Annexe : Liste des interruptions

- 01h: Lancement d'un programme en mode pas-à-pas (permet de le débogueur).
- 02h: Interruption non masquable.
- 03h: Erreur de rupture.
- 04h: Erreur de dépassement (par calcul, exemple : "mov al, 200 ; add al,140" -> 340 > 255 !!!).
- 05h "Imprime écran", imprime une copie de l'écran en mode texte.
- 08h: Horloge tournant à 18.6 clics/seconde.
- 09h: Lecture du clavier. La touche est codée avec un 'code clavier' (scan code en anglais) traduit en code
standart ASCII par l'interruption 16h.
- 0Bh: Gestion du port COM2.
- 0Ch: Gestion du port COM1.
- 10h: Gestion de la carte vidéo.
- 11h : Liste de configuration (mémoire, nombre de ports COM, co-processeur, ...).
- 12h: Taille de la mémoire basse (640 Ko maximum).
- 13h: Gestion des différents disques.
- 14h: Gestion de l'interface série (ports COM, voir les interruptions 0Bh et 0Ch).
- 15h: Manette de jeu, cassette et TopView.
- 16h: Conversion du code de la touche (lu par l'interruption 09h) en code standart ASCII.
- 17h: Gestion de l'imprimante.
- 18h: Rom BASIC.
- 19h: Rountine de chargement du DOS.
- 1Ah: Gestion de l'heure réelle.
- 1Bh: Surveille la pression de la combinaison de touche 'CTRL + C'.
- 1Ch: Chronomètre clic/clic à la vitesse de l'horloge 08h : 18.6 Hz. Sa valeur est stockée à l'emplacement
0040h: 0060h.
- 1Dh: La table d'initialisation vidéo.
- 1Eh: La table de paramètre des disquettes.
- 1Fh: La table des caractères graphiques.
- 20h: L'interruption DOS : Fin d'un programme au format COM (le format EXE est largement plus répendu
aujourd'hui).
- 21h: L'interruption DOS : Fonctions universelles (disque dur, horloge, ...).
- 22h: L'interruption DOS : Adresse de fin de processus.
- 23h: L'interruption DOS : Surveille CTRL + PAUSE (ou CTRL + BREAK).
- 24h: L'interruption DOS : Erreur fatale d'un vecteur d'interruption.
- 25h: L'interruption DOS : Lecture directe d'un disque.
- 26h: L'interruption DOS : Ecriture directe sur un disque.
- 27h: L'interruption DOS : Programmes résidents.
- 28h: Fin d'un programme restant résidant en mémoire.
- 2Fh: Interruption pour plusieurs sous programmes. Gestion du réseau, driver CD-Rom MSCDEX, ...

Par M. JAROU P a g e | 12