l`assembleur sur simulateur

L'ASSEMBLEUR
SUR SIMULATEUR
L'assembleur sur Simulateur
1
M. DALMAU IUT de Bayonne
LE PROCESSEUR
Les registres
Le processeur possède 8 registres de 32 bits :
R0 à R6 registres de 32 bits pouvant être utilisés comme opérandes dans toutes les instructions ou comme
pointeurs pour désigner un opérande en mémoire par son adresse.
SP pointeur de pile utilisé par les procédures et les instructions relatives à la pile (PULL, PUSH).
La mémoire est constituée de 1K mots de 32 bits.
Les opérandes
Le processeur traite les opérandes suivants :
- Entiers naturels sur 32 bits
- Entiers relatifs sur 32 bits en complément à 2
- Caractères en code ASCII
- Chaînes de caractères de codes ASCII
- Pointeurs constitués d'une adresse sur 10 bits.
JEU D'INSTRUCTIONS
Notation : pour simplifier les descriptions ci-dessous on choisira de désigner par :
RG
un registre quelconque (R0 à R6 ou SP)
[RG]
un registre quelconque (R0 à R6 ou SP) utilisé pour désigner un opérande en
mémoire par son adresse (pointeur). Seuls les 10 bits de faible poids de RG sont
utilisés comme adresse.
[RG+d] un registre quelconque (R0 à R6 ou SP) utilisé pour désigner un opérande en
mémoire par son adresse (pointeur). La valeur d (de 0 à 1023) désigne le
déplacement par rapport à cette adresse. L'opérande est donc le mot de la mémoire
dont l'adresse est obtenue en faisant: contenu des 10 bits de faible poids de RG + d.
RG n'est pas modifié.
Var
un opérande en mémoire désigné par son nom (adresse)
Val
une valeur sur 16 bits (– 32767 à +32767).
Instructions de déplacements de données
LD
dest, source
opération : dest ← source
dest peut être RG ou [RG]
source peut être RG ou [RG] ou [RG+d] ou Var ou Val
ST
source, Var
opération : Var ← source
source peut être RG ou [RG]
opération : dest ← adresse en mémoire de la variable désignée.
dest peut être RG ou [RG]
Remarque : cette instruction permet d'initialiser un registre comme pointeur sur une variable. Elle sera,
en particulier utilisée pour initialiser le pointeur de pile (SP) sur le sommet de pile en début de
programme (voir plus loin).
LEA
dest, Var
SWAP
oper
opération : échange les 16 bits de fort poids et les 16 bits de faible poids
de l'opérande qui peut être RG ou [RG] ou [RG+d] ou Var.
L'assembleur sur Simulateur
2
M. DALMAU IUT de Bayonne
Instructions arithmétiques
ADD
SUB
op1 , op2
op1 , op2
opération : op1 ← op1 + op2
opération : op1 ← op1 - op2
MUL
MULU
op1 , op2
op1 , op2
opération : op1 ← op1 * op2 : Multiplication d'entiers relatifs
opération : op1 ← op1 * op2 : Multiplication d'entiers naturels
DIV
DIVU
op1 , op2
op1 , op2
opération : op1 ← op1 / op2 : Division d'entiers relatifs
opération : op1 ← op1 / op2 : Division d'entiers naturels
Dans les 6 instructions précédentes
INC
oper
DEC
oper
NEG
oper
op1 peut être RG ou [RG]
op2 peut être RG ou [RG] ou [RG+d] ou Var ou Val
opération: oper ← oper + 1
L'opérande peut être RG ou [RG] ou [RG+d] ou Var.
opération: oper ← oper - 1
L'opérande peut être RG ou [RG] ou [RG+d] ou Var.
opération: oper ← - (oper)
L'opérande peut être RG ou [RG] ou [RG+d] ou Var.
Remarque : les instructions arithmétiques, à l'exception de NEG, positionnent les indicateurs de
débordement des entiers naturels et relatifs du registre d'état de l'unité de traitement.
Instructions logiques
OR
op1 , op2
opération : op1 ← op1 OU op2
AND
op1 , op2
opération : op1 ← op1 ET op2
Dans ces deux opérations
op1 peut être RG ou [RG]
op2 peut être RG ou [RG] ou [RG+d] ou Var ou Val
NOT
oper
opération: oper ← COMPLEMENT oper
L'opérande peut être RG ou [RG] ou [RG+d] ou Var.
Instruction de comparaison
CMP
op1 , op2
opération : compare op1 à op2
op1 peut être RG ou [RG]
op2 peut être RG ou [RG] ou [RG+d] ou Var ou Val
Ne produit aucun résultat autre que celui de positionner les indicateurs du registre d'état de l'unité de
traitement utilisés par les instructions de branchement.
Instructions de décalage
SHR oper
SHL oper
opération : oper est décalé à droite (décalage logique).
opération : oper est décalé à gauche (décalage logique).
SAR oper
opération : oper est décalé à droite (décalage arithmétique).
SAL oper
opération : oper est décalé à gauche (décalage arithmétique).
ROR oper
opération : oper est décalé à droite (décalage cyclique).
0
DEBER
0
DEBER
DEBER
0
DEBER
DEBER
ROL oper
cyclique).
opération : oper est décalé à gauche (décalage
DEBER
Dans ces instructions l'opérande peut être RG ou [RG] ou [RG+d] ou Var.
DEBER est l'indicateur de débordement des entiers naturels du registre d'état de l'unité de traitement.
L'assembleur sur Simulateur
3
M. DALMAU IUT de Bayonne
Instructions de branchement (rupture de séquence)
JMP
etiq
opération : branchement inconditionnel.
Bxx
etiq
opération : branchement conditionnel.
Dans ces instructions etiq doit être une étiquette (instruction où aller).
Se référer à la table ci-dessous pour les différentes conditions de branchement :
condition
comparaison
d'entiers naturels
comparaison
d'entiers relatifs
BEQ
BNE
BLTU
BLEU
BGTU
BGEU
BDEBU
BEQ
BNE
BLT
BLE
BGT
BGE
BDEB
égal
différent
inférieur
inférieur ou égal
supérieur
supérieur ou égal
débordement
Instructions relatives à la pile
PUSH
PULL
opération : empile oper. (SP ← SP-1 puis Mem(SP) ← oper)
opération : dépile oper. (oper ← Mem(SP) puis SP ← SP+1)
oper
oper
Dans ces instructions l'opérande peut être RG ou [RG] ou [RG+d] ou Var.
Instructions d'appel et retour de sous programmes
CALL
etiq
RET
RET
Val
opération: appel du sous-programme référencé par etiq.
etiq doit être une étiquette (instruction de début de la procédure)
opération : retour de sous-programme.
opération : retour de sous-programme avec vidage de la pile.
La valeur en opérande indique le nombre de mots en sommet de pile à
enlever (ignorer) après le retour. Ces mots correspondent à des paramètres
mis dans la pile avant l'appel du sous-programme et que l'on désire enlever à
la fin.
Instruction de contrôle
HLT
opération : arrêt du processeur
Instructions relatives à l'unité d'échange (Entrées / Sorties)
IN
OUT
oper, port
oper, port
opération : oper ← octet du registre de l'unité d'échange désigné par son n°.
opération : octet du registre de l'unité d'échange désigné par son n° ← oper.
Dans ces instructions oper peut être RG ou [RG], port est un entier naturel désignant le n° de port de
l'unité d'échange. Seuls les 8 bits de faible poids de oper sont utilisés.
L'assembleur sur Simulateur
4
M. DALMAU IUT de Bayonne
L'ASSEMBLEUR DU SIMULATEUR
La syntaxe d'une ligne d'assembleur est :
[etiquette:] [COP [operande1 [, operande2]]] [; commentaire]
Où un terme noté entre crochets est facultatif.
• Une étiquette est un mot qui ne doit comporter aucun caractère défini comme délimiteur par le
langage ( ' " ; , [ ] ) ni d'espaces. Elle peut contenir des caractères accentués et elle doit être
terminée par :
• Le COP est l'un des codes définis précédemment il peut indifféremment être écrit en minuscules ou
en majuscules.
• Un commentaire débute au ; et se termine à la fin de la ligne. Il peut contenir tous les caractères sauf
des guillemets ( " ).
Désignation des opérandes dans les instructions autres que celles de rupture de
séquence :
Registre : On met le nom du registre qui contient l'opérande (en majuscules ou minuscules)
exemple :
LD
R0,r1 ; R0 ← R1
Valeur immédiate : On met la valeur de l'opérande selon la forme :
décimal
123 ou –4
valeur de 0 à 655355 ou –32767 à 32767
hexadécimal
$1a ou $ffa3
valeur sur 16 bits (4 digits hexadécimaux au maximum)
binaire
%01110010
valeur sur 16 bits (16 chiffres binaires au maximum)
ASCII
'a'
code ASCII d'un caractère
ATTENTION : Le caractère placé entre ' ne peut être " ni ; car ce sont des délimiteurs définis dans le
langage (délimiteurs de chaîne de caractères et de commentaire)
exemples :
LD
R1,$ff03 ; R1 ← FF03 en hexadécimal
LD
R2,'A'
; R2 ← code ASCII de 'A'
Direct : On met le nom de la variable
exemples :
LD
R0,var1 ; R0 ← contenu de var1
ST
R2,var2 ; var2 ← contenu de R2
ATTENTION : Un nom de variable doit commencer par une lettre et ne comporter aucun caractère
défini comme délimiteur par le langage ( ' " ; , [ ] ). Le compilateur distingue les majuscules et les
minuscules et accepte les caractères accentués. De plus un nom de variable ne doit pas pouvoir être
confondu avec un nom de registre ni être le mot clé STACK.
Indirect : Le registre désigné contient l'adresse de l'opérande (seuls les 10 bits de faible poids du
registre sont pris en compte). On met le nom du registre entre crochets.
exemples : LD R0,[SP]
; R0 ← contenu de la mémoire à l'adresse contenue dans SP
LD [R1],12
; mémoire à l'adresse contenue dans R1 ← 12
LD [R1],r3
; mémoire à l'adresse contenue dans R1 ← contenu de R3
LD [r1],var
; mémoire à l'adresse contenue dans R1 ← contenu de var
ST [R2],var2
; var2 ← contenu de la mémoire à l'adresse contenue dans R2
LD [sp],[R1]
; mémoire à l'adresse contenue dans SP ← contenu de la
mémoire à l'adresse contenue dans R1
Désignation des opérandes dans les instructions de rupture de séquence :
On met l'étiquette qui désigne l'instruction à laquelle on doit aller (le nom seul de l'étiquette sans les :).
exemple :
BNE début
L'assembleur sur Simulateur
5
M. DALMAU IUT de Bayonne
Les zones du programme :
Un programme possède 3 zones :
• Une zone réservée aux déclarations de variables
• Une zone réservée aux instructions
• Une zone réservée à la pile
La zone de pile est définie par la directive .STACK taille où taille indique le nombre de mots de la
mémoire réservés pour la pile.
On définit les autres zones comme suit :
code :
.CODE
données :
.DATA
Lors du chargement du programme le registre CO est initialisé sur la première instruction qui suit la
directive .CODE. Les autres registres ne sont pas modifiés.
Par contre, le registre SP doit être initialisé par le programme pour désigner le sommet de pile, ceci se
fait grâce à l'instruction :
LEA SP,STACK
; attention le mot clé STACK doit être en majuscules
Déclaration des variables :
1. Variables non initialisées :
nom
DSW taille
Déclare une variable appelée nom occupant taille mots en mémoire.
Remarque : nom peut être omis, dans ce cas il y a réservation de place en mémoire sans nom de variable
associé.
2. Variables initialisées :
nom
DW
valeur
Déclare une variable appelée nom initialisée à valeur. Les possibilités pour valeur sont :
Un entier décimal:
1239877 ou -4
de 0 à 4294967295 ou de – 2147483647 à 2147483647
Un entier hexadécimal: $1a ou $ffa3
valeur sur 32 bits (8 digits hexadécimaux maximum)
Une valeur binaire:
%01110010
valeur sur 32 bits (32 chiffres binaire maximum)
Un caractère:
'a'
code ASCII du caractère étendu à 32 bits
Une chaîne de caractères "Bonjour"
un code ASCII étendu à 32 bits par mot
Une variable initialisée occupe un mot de la mémoire sauf dans le cas d'une initialisation par une chaîne
où la variable occupe un mot par caractère de la chaîne.
ATTENTION : Le caractère placé entre ' ne peut être " ni ; car ce sont des délimiteurs définis dans le
langage (chaîne de caractères et commentaire). Les caractères sont représentés par leur code ASCII
étendu à 32 bits en complétant par des 0 à gauche.
Remarque : pour déclarer une variable initialisée contenant plusieurs valeurs, il faut reproduire le mot
clé DW pour chaque valeur sans mettre de nouveau nom de variable.
exemples :
var1 DW
car
DW
var2 DW
var3 DSW
var4 DW
var5
var6
DW
DW
DW
DW
12
'!'
-1
12
"ABC"
11
22
"je"
0
var1 occupe un mot qui contient 12
car occupe un mot qui contient le code ASCII de '!'
var2 occupe un mot qui contient -1
var3 occupe 12 mots non initialisés
var4 occupe 3 mots dont le 1er contient le code ASCII de 'A',
le deuxième celui de 'B' et le dernier celui de 'C'.
var5 occupe 2 mots initialisés à 11 pour le premier et 22 pour le second
var6 occupe 3 mots dont le 1er contient le code ASCII de 'j',
le deuxième celui de 'e' et le dernier la valeur 0.
L'assembleur sur Simulateur
6
M. DALMAU IUT de Bayonne
Squelette d'un programme en assembleur :
truc:
machin:
.DATA
définition des variables et constantes
.CODE
LEA SP,STACK
............................. suite du code
dernière instruction (en général HLT)
......... corps de la procédure truc (1ere procédure)
ret
x
............................. autres procédures
......... corps de la procédure machin (dernière procédure)
RET x
.STACK taille
Le programme démarre à la première instruction qui suit la directive .CODE. L'instruction HLT est
utilisée pour arrêter le processeur à la fin du programme.
L'assembleur sur Simulateur
7
M. DALMAU IUT de Bayonne
UTILISATION DU SIMULATEUR POUR COMPILER
ET EXECUTER UN PROGRAMME
Présentation :
Le simulateur se présente sous la forme des fenêtres suivantes :
• Le panneau de contrôle qui permet de compiler des programmes et des exécuter.
• Le processeur qui contient les registres, l'unité de traitement et l'unité de contrôle.
• La mémoire.
• L'unité d'échange.
• Un périphérique constitué d'une écran graphique de 256x256 et d'un clavier à 6 touches.
Le Panneau de contrôle :
Réglage de la vitesse de l'horloge du processeur
Exécuter un programme résidant en
mémoire
Choix du mode d'exécution des programmes
(en pas à pas ou en continu)
Arrêter un programme en cours
Charger un programme en mémoire
Compiler un programme
Terminer le programme de
simulation
Témoin de programme en cours d'exécution
Le Processeur :
Les registres
L'unité de traitement
L'unité de
contrôle
Le registre d'état de l'UAL
Activité en cours
Le processeur possède 6 registres d'usage général (R0 à R6) plus un registre de sommet de pile SP.
L'assembleur sur Simulateur
8
M. DALMAU IUT de Bayonne
L'unité de contrôle contient :
• Le compteur ordinal CO
• Le registre d'instructions RI
• Une ligne d'état indiquant l'activité en cours: recherche d'instruction, décodage d'instruction, exécution
d'instruction ou arrêt.
L'unité de traitement contient une UAL avec ses registres d'entrée (RA et RB), de sortie (RS) et son
registre d'état. Le registre d'état a la structure suivante :
Indicateur d'égalité
Indicateur
d'infériorité entre
entiers naturels
Indicateur
d'infériorité entre
entiers relatifs
Indicateur de
débordement
d'opération entre
entiers naturels
Indicateur de
débordement
d'opération entre
entiers relatifs
• L'indicateur d'égalité est mis à 1 par une instruction de comparaison (CMP) lorsque les 2 opérandes
sont égaux.
• L'indicateur d'infériorité entre entiers naturels est mis à 1 par une instruction de comparaison (CMP)
lorsque le 1er opérande considéré comme un EN est inférieur au second opérande considéré lui
aussi comme un EN.
• L'indicateur d'infériorité entre entiers relatifs est mis à 1 par une instruction de comparaison (CMP)
lorsque le 1er opérande considéré comme un ER est inférieur au second opérande considéré lui
aussi comme un ER.
• L'indicateur de débordement d'opération entre entiers naturels est mis à 1 par une instruction
arithmétique lorsque le résultat considéré comme un EN déborde.
• L'indicateur de débordement d'opération entre entiers relatifs est mis à 1 par une instruction
arithmétique lorsque le résultat considéré comme un ER déborde.
Remarque : lorsque l'on clique sur un registre, une fenêtre de
dialogue permettant de choisir le mode selon lequel le contenu de
ce registre sera affiché à l'écran (voir ci-contre) apparaît. Bien
entendu cela ne modifie pas le contenu du registre mais seulement
son mode d'affichage.
La Mémoire :
Elle est constitué de 1024 mots de 32 bits.
Un ascenseur permet de faire défiler l'ensemble de son contenu.
Remarque : lorsque l'on clique sur un mot de la mémoire une
fenêtre de dialogue permettant de choisir le mode selon lequel le
contenu de ce mot sera affiché à l'écran (voir ci-dessus)
apparaît. Bien entendu cela ne modifie pas le contenu du mot
mémoire mais seulement son mode d'affichage.
La ligne de menu
"Mode
d'affichage"
permet d'appliquer un
mode d'affichage à une
zone
de
mémoire
comprise entre deux
adresses. Lorsque l'on
clique sur ce menu, on voit apparaître une fenêtre permettant de
choisir l'adresse de début et celle de fin de la zone de mémoire à
laquelle va s'appliquer le mode d'affichage choisi.
Afin d'en faciliter la lecture, lorsqu'un programme est chargé
dans la mémoire le mode d'affichage de chaque mot est adapté
L'assembleur sur Simulateur
9
M. DALMAU IUT de Bayonne
selon le type de son contenu. Il peut être modifié par la suite en cliquant dessus.
L'unité d'échange :
Elle contient 8 registres de 8 bits correspondant aux numéros de port 0 à 7.
Elle permet de connaître l'état des touches et de dessiner ou écrire dans le fenêtre
graphique du périphérique. Elle permet aussi de détecter les mouvements et les clics
de la souris dans la zone graphique de l'écran du périphérique.
Son fonctionnement est le suivant :
1°) Entrées
Le clavier
Les touches du clavier positionnent des valeurs dans le Port0 selon le principe
suivant :
Etat du clavier
bit 7
bit 6
bit 5
Numéro de la touche
bit 3
bit 2
bit 4
bit 1
bit 0
Etat du clavier indique les actions qui ont eu lieu sur le clavier depuis la dernière fois que le Port0 a été lu :
• 00 rien ne s'est produit
Le bit 7 permet donc de savoir si un événement
• 11 une touche a été appuyée
s'est produit, tandis que le bit 6 précise lequel.
• 10 une touche a été lâchée
Remarque : Ces deux bits sont automatiquement remis à 0 lorsque le processeur lit le contenu du Port0.
Numéro de la touche indique le numéro de la touche appuyée ou lâchée. Les numéros des touches sont les
suivants :
• 1 pour la touche ↑
• 2 pour la touche →
• 3 pour la touche ↓
• 4 pour la touche ←
• 5 pour la touche A
• 6 pour la touche B
Remarque : Ces 6 bits sont automatiquement remis à 0 lorsque le processeur lit le contenu du Port0.
L'écran
• Lorsque la souris survole l'écran, ses coordonnées sont écrites dans Port6 (coordonnée en x) et Port7
(coordonnée en y). Un programme peut donc en permanence savoir où se trouve la souris sur l'écran
en lisant ces 2 ports de l'UE.
• Lorsque l'on clique avec la souris sur l'écran, ses coordonnées sont écrites dans Port6 (coordonnée en
x) et Port7 (coordonnée en y) et le Port 0 est positionné de la même façon que si l'on avait appuyé la
touche de numéro 7 (valeur : 11000111).
Remarque : Le Port0 est automatiquement remis à 0 lorsque le processeur en lit le contenu.
2°) Sorties
Les registres Port1 à Port5 pilotent l'écran graphique. Le registre Port5 indique l'opération graphique à
exécuter tandis que les registres Port1 à Port4 en constituent les paramètres.
Dès qu'une valeur est écrite dans Port5, la commande est exécutée en utilisant les registres Port1 à Port4
comme paramètres (il faut donc les avoir préparés avant).
Le Port5 est divisé en 2 demi-registres de 4 bits chacun, les 4 bits de gauche indiquent la couleur dans
laquelle doit se faire le tracé (si la commande est une commande de dessin ou d'écriture). Les 4 bits de
droite indiquent la commande à exécuter :
bit 7
Couleur de tracé
bit 6
bit 5
L'assembleur sur Simulateur
bit 4
bit 3
10
Commande graphique
bit 2
bit 1
bit 0
M. DALMAU IUT de Bayonne
Les Commandes graphiques sont les suivantes :
• 0000 : effacer l'écran, les 4 bits Couleur de tracé sont ignorés.
• 0001 : tracer le point dont les coordonnées sont dans Port1 (coordonnée en x) et Port2 (coordonnée
en y). La couleur de tracé est celle indiqué par les 4 bits Couleur de tracé.
• 0010 : tracer la ligne dont les coordonnées du point de départ sont dans Port1 (coordonnée en x) et
Port2 (coordonnée en y) celles du point d'arrivée sont dans Port3 (coordonnée en x) et Port4
(coordonnée en y). La couleur de tracé est celle indiqué par les 4 bits Couleur de tracé.
• 0011 : tracer le rectangle dont les coordonnées du coin supérieur gauche sont dans Port1
(coordonnée en x) et Port2 (coordonnée en y), la largeur est dans Port3 et la hauteur dans Port4.
La couleur de tracé est celle indiqué par les 4 bits Couleur de tracé.
• 0100 : tracer l'ovale inscrit dans le rectangle dont les coordonnées du coin supérieur gauche sont
dans Port1 (coordonnée en x) et Port2 (coordonnée en y), la largeur est dans Port3 et la hauteur
dans Port4. La couleur de tracé est celle indiqué par les 4 bits Couleur de tracé.
• 0101 : tracer le rectangle plein dont les coordonnées du coin supérieur gauche sont dans Port1
(coordonnée en x) et Port2 (coordonnée en y), la largeur est dans Port3 et la hauteur dans Port4.
La couleur de remplissage est celle indiqué par les 4 bits Couleur de tracé.
• 0110 : tracer l'ovale plein inscrit dans le rectangle dont les coordonnées du coin supérieur gauche
sont dans Port1 (coordonnée en x) et Port2 (coordonnée en y), la largeur est dans Port3 et la
hauteur dans Port4. La couleur de remplissage est celle indiqué par les 4 bits Couleur de tracé.
• 0111 : écrire aux coordonnées placées dans Port1 (coordonnée en x) et Port2 (coordonnée en y) le
caractère dont le code ASCII est placé dans Port3. La couleur d'écriture est celle indiqué par les 4
bits Couleur de tracé. La valeur des coordonnées en x (Port1) et en y (Port2) sont
automatiquement mises à jour pour pouvoir écrire le caractère suivant sur la même ligne ou, si
elle est pleine, sur la ligne suivante.
Les Couleurs de tracé sont les suivantes :
0000 : noir
0100 : bleu foncé
0001 : gris foncé
0101 : bleu clair
0010 : gris moyen
0110 : cyan
0011 : gris clair
0111 : vert
1000 : vert clair
1001 : magenta
1010 : orange
1011 : rose
1100 : rouge vif
1101 : rouge clair
1110 : jaune
1111 : blanc
Le périphérique :
1°) L'écran
L'écran est graphique d'une définition de 256 pixels par 256
pixels. Les coordonnées (0,0) correspondent au coin supérieur
gauche. Les coordonnées en x (horizontalement) augmentent
quand on se déplace vers la droite, les coordonnées en y
(verticalement) augmentent quand on se déplace vers le bas.
L'écran détecte les mouvements et les clics de la souris sur sa
surface.
2°) Les touches
Le périphérique comporte 6 touches (comme une gameboy
simple): 4 touches de direction et 2 touches de commande (A et
B). Les touches peuvent être activées à la souris ou en utilisant
le clavier.
Pour pouvoir utiliser le clavier la fenêtre du périphérique doit
être la fenêtre active. Les touches correspondantes du clavier
sont les flèches pour les touches de direction, la touche Espace
pour la touche de commande A et la touche Entrée pour la
touche de commande B.
L'assembleur sur Simulateur
11
M. DALMAU IUT de Bayonne
Utiliser le simulateur :
Le simulateur est contenu dans un fichier d'archives Java (simulateur.jar). Le programme peut être
lancé en double cliquant sur le fichier jar ou par la commande : java –jar simulateur.jar
Pour exécuter un programme :
1°) Taper le programme source à l'aide d'un éditeur de textes quelconque en mode txt et l'enregistrer
sous un nom de la forme : xxxx.asm
2°) Appeler le compilateur par le bouton approprié du simulateur. Après avoir choisi un fichier .asm à
compiler, une fenêtre s'ouvre pour indiquer l'état de la compilation (et les erreurs éventuelles). Si la
compilation ne génère pas d'erreurs, un fichier exécutable xxxx.mpc est obtenu et placé dans le même
répertoire que xxxx.asm. On peut alors fermer la fenêtre du compilateur.
Remarque : Au moment de la compilation le réglage de vitesse d'horloge et l'état de la case à cocher
"pas à pas" du simulateur sont mémorisés. Ainsi, lorsque le fichier sera chargé en mémoire, la case à
cocher et l'horloge retrouveront les valeurs qu'elles avaient au moment de la compilation du fichier.
3°) Charger le programme ainsi obtenu par le bouton approprié du simulateur qui permet de choisir le
fichier .mpc à exécuter. Le programme est maintenant visible en mémoire et le CO est initialisé sur la
première instruction. En outre, la case à cocher et l'horloge ont retrouvé les valeurs qu'elles avaient au
moment de la compilation de ce fichier. Elles peuvent, bien évidemment, être modifiées.
4°) Lancer le programme par le bouton Exécuter. Le curseur du haut permet de régler la vitesse de
l'horloge du processeur. Ainsi les instructions s'exécuteront plus ou moins vite selon ce réglage. Ceci
permet en particulier de suivre l'exécution d'un programme et de vérifier que tout se passe bien.
Chaque fois qu'un registre est modifié il apparaît un bref instant en rouge. Chaque fois qu'un registre est
lu il apparaît un bref instant en vert. Lorsque l'horloge est mise à sa vitesse maximale, les changements
de couleurs des registres ne sont plus visibles.
La case à cocher permet de choisir un fonctionnement en pas à pas ou en continu. En mode pas à pas le
processeur s'arrête à la fin de chaque instruction. Pour qu'il effectue l'instruction suivante du programme
il faut ré-activer le bouton Exécuter. En mode continu il exécute les instructions l'une après l'autre
jusqu'à rencontrer une instruction HLT. On peut toutefois l'arrêter en utilisant le bouton Stop. Toutefois
ce bouton n'arrête l'exécution qu'après que l'instruction en cours soit terminée.
L'assembleur sur Simulateur
12
M. DALMAU IUT de Bayonne