:: Enseignements :: Licence :: L3 :: 2007-2008 :: Architecture des ordinateurs ::
| Petit manuel d'utilisation de SPIM |
Le site officiel de SPIM est
http://www.cs.wisc.edu/~larus/spim.html, on peut à partir de ce
site télécharger le simulateur pour différentes plates-formes
ainsi que la documentation (en anglais). L'annexe A de "D.
Patterson et J. Henessy : Organisation et conception des
ordinateurs, DUNOD 1994" -- disponible
ici
-- contient aussi une description de SPIM. Ce document s'en
inspire fortement.
Introduction
SPIM est un simulateur qui exécute des programmes en
assembleur MIPS R2000/R3000. Le simulateur est beaucoup plus
lent qu'une machine réelle (un facteur 100 au minimum) mais
offre les avantages suivants :
- Très faible coût et large disponibilité,
-
Simule l'architecture MIPS R2000/R3000 qui est simple et
claire et donc idéale pour l'enseignement,
-
Offre un environnement de programmation convivial et
performant (interfac X-window)
Un autre avantage de SPIM réside dans le fait qu'il simule
par défaut une machine MIPS virtuelle. En effet,
l'architecture MIPS comme celle de la plupart des machines
RISC est difficile à programmer directement en raison des
branchements et des chargements différés ainsi que des modes
d'adressage limités. MIPS dissimule cette complexité en
faisant réaliser une
machine virtuelle
par son assembleur. Cet ordinateur virtuel possède des
branchements et des chargements non différés et un jeu
d'instructions plus riche que la machine réelle.
L'assembleur réorganise les instructions pour combler les
délais d'attente et simule les
pseudo-instructions
par de courtes séquences d'instructions réelles. Par défaut,
SPIM simule la machine virtuelle plus riche mais il peut
aussi simuler le matériel brut.
1 - L'interface SPIM
Il existe deux versions du simulateur, l'une sur terminal (
spim
) et la version X-window (
xspim
), nous ne décrirons dans ce document que la version
X-xindow.
Les options utiles de ligne de commande de cette version
sont :
-
-bare
Simule la machine brute et non pas la machine
virtuelle. Implique
-quiet
-
-notrap
Ne charge pas le code standard de gestion des
exceptions et de démarrage. Lorsqu'une exception
survient, SPIM effectue un saut vers l'emplacement
80000080[hex]>
qui doit contenir du code pour traiter l'exception.
Sans la pocédure de démarrage, SPIM démarre
l'exécution à l'instruction étiquetée
__start
.
-
-mapped_io
Active la fonction d'E/S à correspondance mémoire
(voir Section 2.4). Les programmes qui utilisent les
appels SPIM (voir Section 2.3) pour lire et écrire
sur le terminal
ne peuvent pas
simultanément utiliser les E/S à correspondance
mémoire.
Les autres options sont :
-asm
,
-trap
,
-noquiet
,
-quiet
,
-nomapped_io
,
-file
,
-execute
,
-ssed taille
et
-lseg taille
. Leur utilisation est décrite dans les documents sités plus
haut.
La fenêtre X de XSPIM a cinq panneaux.
Le panneau supérieur affiche le contenu des registres. Ces
valeurs sont mises à jour en permanence.
La panneau suivant contient les boutons qui contrôlent le
simulateur :
-
quit
Sortie du simulateur
-
load
Lecture d'un fichier source
-
run
Lance l'exécution du programme dans sa totalité
-
step
Lance l'exécution pas à pas du programme
-
clear
Réinitialise les registres et la mémoire
-
set value
Définit la valeur d'un registre ou d'un emplacement
mémoire
-
print
Affiche la valeur d'un registre ou d'un emplacement
mémoire
-
breakpoint
Définit ou supprime un point d'arrêt ou donne la
liste de tous les points d'arrêt
-
help
Affiche un message d'aide
-
terminal
Montre ou dissimule la fenere "console"
-
mode
Définit les modes de fonctionnement de SPIM
Les deux panneaux suivants affichent la mémoire. Celui du
haut montre les instructions issues des segments de texte et
des segments noyau de l'utilisateur. (Ces instructions sont
des instructions MIPS réelles et non des
pseudo-instructions. SPIM traduit ces dernières en 1 à 3
instructions MIPS. Chaque instruction source apparaît comme
un commentaire sur la première des instructions en laquelles
elle est traduite.)
Les toutes premières instructions du segment de texte
définissent le code de démarrage par défaut (
__start
) qui appelle la procédure
main
.
Le panneau du bas affiche les segments de données et de
pile.
Les deux panneaux sont mis à jours au cours de l'exécution
du programme.
Le panneau inférieur de la fenêtre X est utilisé pour
afficher des messages SPIM. Il n'affiche pas la sortie du
programme. Lorsqu'un programme lit ou écrit, ses E/S
apparaissent dans une fenêtre séparée, la "console", qui
s'ouvre lorsque cela s'avère utile.
2 - L'assembleur MIPS
2.1 - Syntaxe
Les commentaires dans les fichiers assembleur commencent
par le symbole dièse (
#
). Tout ce qui est situé entre le dièse et la fin de
ligne est ignoré.
Un identificateur est une séquence de caractères
alphanumériques, de traits bas (
_
) et de points (
.
), qui ne commence pas par un chiffre. Les "codes-op"
d'instruction sont des mots réservés qui
ne peuvent pas
être utilisés comme identificateurs.
Les étiquettes sont déclarées en les plaçant au début
d'une ligne et en les faisant suivre du symbole
:
.
Les nombres sont en base 10 par défaut. Si ils sont
précédés de
0x
, ils sont interprétés comme héxadécimaux (
256
et
0x100
représentent la mêm valeur).
Les chaînes de caractères sont encadrées par des doubles
apostrophes (
"
). Certains caractères spéciaux dans les chaînes suivent
la convention C : retour-chariot -
\n
; tabulation -
\t
; apostrophe -
\"
.
2.2 - Directives d'assemblage
SPIM supporte un sous-ensemble des directives de
l'assembleur MIPS :
-
.align n
Aligne la donnée suivante sur une frontière de
2^n octets.
-
.ascii car
Enregistre en mémoire la chaîne de caractères
car
, mais ne la termine pas par un caractère
nul
.
-
.asciiz car
Enregistre en mémoire la chaîne de caractères
car
, et la termine par un caractère
nul
.
-
.byte b1, ...,bn
Enregistre les n valeurs dans des octets
consécutifs en mémoire.
-
.data <adr>
Les éléments qui suivent sont enregistrés dans
le segment de données, à partir de l'adresse
adr
si elle est précisée.
-
.double d1, ..., dn
Enregistre les n flottants double précision dans
des emplacements mémoire consécutifs.
-
.float f1, ..., fn
Enregistre les n flottants simple précision dans
des emplacements mémoire consécutifs.
-
.gobl sym
Déclare que le symbole
sym
est global, on peut y faire référence à partir
d'autres fichiers.
-
.half h1, ..., hn
Enregistre en mémoire les n valeurs sur 16 bits
dans des demi-mots consécutifs.
-
.text <adr>
Les éléments de données qui suivent sont
stockées dans le segment de données de texte de
l'utilisateur à partir de l'adresse
adr
si elle est précisée.
-
.word w1, ..., wn
Enregistre en émoire les n valeurs sur 32 bits
dans des mots consécutifs.
2.3 - Les appels système
SPIM fournit un petit ensemble de services de type système
d'exploitation par l'intermédiaire de l'instruction d'appel
système
syscall
. Pour demander un service, un programme charge le code de
l'appel système (voir Table ci-après) dans le registre
$v0
et ses arguments dans les registres
$a0, ..., $a3
(ou
$f12
pour les valeurs flottantes). Les appels systèmes qui
retournent des valeurs placent leurs résultats dans le
registre
$v0
(ou
$f0
pour les résultats flottants).
Les chaînes de caractères dans
print_string
et
read_string
sont à terminaison nulle.
sbrk
retourne un pointeur sur un bloc de mémoire contenant n
octets supplémentaires et
exit
stoppe l'exécution d'un programme.
|------------------------------------------------------------------------------------------|
| Service | Code | Arguments | Résultats |
|------------------------------------------------------------------------------------------|
| print_int | 1 | $a0 = entier | |
| print_float | 2 | $f12 = flottant simple précision | |
| print_double | 3 | $f12 = flottant double précision | |
| print_string | 4 | $a0 = chaîne de caractères | |
| read_int | 5 | | $v0 = entier |
| read_float | 6 | | $f0 = flottant simple précision |
| read_double | 7 | | $f0 = flottant double précision |
| read_string | 8 | $a0 = buffer, $a1 = longueur | |
| sbrk | 9 | $a0 = quantité | $v0 = une adresse |
| exit | 10 | | |
|------------------------------------------------------------------------------------------|
2.4 - Les Entrées Sorties
SPIM simule un dispositif d'E/S : un terminal à
correspondance mémoire. Lorsqu'un programme s'exécute, SPIM
connecte une fenêtre "console" (le terminal) au processeur.
Le terminal est constitué de deux unités indépendantes : un
récepteur et un émetteur. Le récepteur lit des caractères
sur le clavier, l'émetteur écrit des caractères sur l'écran.
2.5 - Les instructions MIPS
Dans toutes les instructions suivantes,
Src2
est soit un registre soit une valeur immédiate (sur 16
bits),
Rsrc1
,
Rsrc2
et
Rdest
sont des registres et
Imm
est une valeur immédiate. Si rien n'est précisé dans la
colonne "commentaires", l'instruction est une instruction de
base de la machine. Si c'est une pseudo-instruction, SPIM le
transformera en une suite d'instructions de base.
2.5.1 - Instructions arithmétiues et logiques
|----------------------------------------------------------------------------|
| Syntaxe | Description | Commentaires |
|----------------------------------------------------------------------------|
| abs Rdest, Rsrc1 | Valeur absolue | pseudo-instruction |
|----------------------------------------------------------------------------|
| add Rdest, Rsrc1, Src2 | Addition avec overflow | pseudo si Src2=Imm |
|----------------------------------------------------------------------------|
| addi Rdest, Rsrc1, Imm | Addition immédiate avec | |
| | overflow | |
|----------------------------------------------------------------------------|
| addu Rdest, Rsrc1, Src2 | Addition sans overflow | pseudo si Src2=Imm |
|----------------------------------------------------------------------------|
| addiu Rdest, Rsrc1, Imm | Addition immédiate sans | |
| | overflow | |
|----------------------------------------------------------------------------|
| and Rdest, Rsrc1, Src2 | ET | pseudo si Src2=Imm |
|----------------------------------------------------------------------------|
| andi Rdest, Rsrc1, Imm | ET immédiat | |
|----------------------------------------------------------------------------|
| div Rsrc1, Rsrc2 | Division signée (1) | |
|----------------------------------------------------------------------------|
| divu Rsrc1, Rsrc2 | Division non signée (1) | |
|----------------------------------------------------------------------------|
| div Rdest, Rsrc1, Src2 | Division signée avec | pseudo-instruction |
| | overflow (2) | |
|----------------------------------------------------------------------------|
| divu Rdest, Rsrc1, Src2 | Division non signée sans | pseudo-instruction |
| | overflow (2) | |
|----------------------------------------------------------------------------|
| mul Rdest, Rsrc1, Src2 | Multiplication sans | pseudo-instruction |
| | overflow (3) | |
|----------------------------------------------------------------------------|
| mulo Rdest, Rsrc1, Src2 | Multiplication avec | pseudo-instruction |
| | débordement (3) | |
|----------------------------------------------------------------------------|
| mulou Rdest, Rsrc1, Src2 | Multiplication non signée | pseudo-instruction |
| | avec débordement (3) | |
|----------------------------------------------------------------------------|
| mult Rsrc1, Rsrc2 | Multiplication (4) | |
|----------------------------------------------------------------------------|
| multu Rsrc1, Rsrc2 | Multiplication non signée | |
| | (4) | |
|----------------------------------------------------------------------------|
| neg Rdest, Rsrc1 | Opposé avec overflow | pseudo-instruction |
|----------------------------------------------------------------------------|
| negu Rdest, Rsrc1 | Opposé sans overflow | pseudo-instruction |
|----------------------------------------------------------------------------|
| nor Rdest, Rsrc1, Src2 | NON OU | pseudo si Src2=Imm |
|----------------------------------------------------------------------------|
| not Rdest, Rsrc1 | Négation bit à bit | pseudo-instruction |
|----------------------------------------------------------------------------|
| or Rdest, Rsrc1, Src2 | OU | pseudo si Src2=Imm |
|----------------------------------------------------------------------------|
| ori Rdest, Rsrc1, Imm | OU immédiat | |
|----------------------------------------------------------------------------|
| rem Rdest, Rsrc1, Rsrc2 | Reste (5) | pseudo-instruction |
|----------------------------------------------------------------------------|
| remu Rdest, Rsrc1, Rsrc2 | Reste non signé (5) | pseudo-instruction |
|----------------------------------------------------------------------------|
| rol Rdest, Rsrc1, Src2 | Rotation vers la gauche (6)| pseudo-instruction |
|----------------------------------------------------------------------------|
| ror Rdest, Rsrc1, Src2 | Rotation vers la droite (6)| pseudo-instruction |
|----------------------------------------------------------------------------|
| sll Rdest, Rsrc1, Src2 | Décalage logique vers la | pseudo si Src2=Reg |
| | gauche (7) | |
|----------------------------------------------------------------------------|
| sllv Rdest, Rsrc1, Rsrc2 | Décalage logique variable | |
| | vers la gauche (8) | |
|----------------------------------------------------------------------------|
| sra Rdest, Rsrc1, Src2 | Décalage arithmétique vers | pseudo si Src2=Reg |
| | la droite (7) | |
|----------------------------------------------------------------------------|
| srav Rdest, Rsrc1, Rsrc2 | Décalge arithmétique (8) | |
| | variable vers la droite | |
|----------------------------------------------------------------------------|
| srl Rdest, Rsrc1, Src2 | Décalage logique vers la | pseudo si Src2=Reg |
| | droite (7) | |
|----------------------------------------------------------------------------|
| srlv Rdest, Rsrc1, Rsrc2 | Décalage logique variable | |
| | vers la droite (8) | |
|----------------------------------------------------------------------------|
| sub Rdest, Rsrc1, Src2 | Soustraction avec overflow | pseudo si Src2=Imm |
|----------------------------------------------------------------------------|
| subu Rdest, Rsrc1, Src2 | Soustraction sans overflow | pseudo si Src2=Imm |
|----------------------------------------------------------------------------|
| xor Rdest, Rsrc1, Src2 | OU exclusif | pseudo si Src2=Imm |
|----------------------------------------------------------------------------|
| xori Rdest, Rsrc1, Imm | OU exclusif immédiat (9) | |
|----------------------------------------------------------------------------|
(1) Divise Rsrc1 par Rsrc2; laisse le quotient dans le registre lo et le reste
dans le registre hi. Il faut noter que si un opérande est négatif, le reste
n'est pas défini par l'architecture MIPS et dépend de la convention de la
machine sur laquelle SPIM s'exécute.
(2) Place le quotient de la division de Rsrc1 par Src2 dans le registre Rdest
(3) Place le produit de Rsrc1 par Src2 dans le registre Rdest
(4) Place le produit de Rsrc1 et Rsrc2 dans les registres lo (poids failbes)
et hi (poids forts)
(5) Place le reste de la division de Rsrc1 par Rsrc2 dans le registre Rdest.
(6) Rotation de la distance indiquée par Src2
(7) Décalage de la distance indiquée par Src2
(8) Décalage de la distance indiquée par le registre Rsrc2
(9) L'immédiat est étendu par des zéros
2.5.2 - Instructions de manipulation de constantes
|----------------------------------------------------------------------------|
| Syntaxe | Description | Commentaires |
|----------------------------------------------------------------------------|
| li Rdest, Imm | Chargement d'un immédiat | pseudo-instruction |
|----------------------------------------------------------------------------|
| lui Rdest, Imm | Chargement d'un immédiat | pseudo si Imm sur plus de |
| | en partie haute (1) | 16 bits |
|----------------------------------------------------------------------------|
(1) Dans les 16 bits de poids forts de Rdest, les bits de poids faibles du
registre sont mis à zéro
2.5.3 - Instructions de comparaison
|----------------------------------------------------------------------------|
| Syntaxe | Description | Commentaires |
|----------------------------------------------------------------------------|
| seq Rdest, Rsrc1, Src2 | Positionner si égal (1) | pseudo-instruction |
|----------------------------------------------------------------------------|
| sge Rdest, Rsrc1, Src2 | Positionner si >= (2) | pseudo-instruction |
|----------------------------------------------------------------------------|
| sgeu Rdest, Rsrc1, Src2 | Positionner si >= non signé| pseudo-instruction |
| | (2) | |
|----------------------------------------------------------------------------|
| sgt Rdest, Rsrc1, Src2 | Positionner si > (3) | pseudo-instruction |
|----------------------------------------------------------------------------|
| sgtu Rdest, Rsrc1, Src2 | Positionner si > non signé| pseudo-instruction |
| | (3) | |
|----------------------------------------------------------------------------|
| sle Rdest, Rsrc1, Src2 | Positionner si <= (4) | pseudo-instruction |
|----------------------------------------------------------------------------|
| sleu Rdest, Rsrc1, Src2 | Positionner si <= non signé| pseudo-instruction |
| | (4) | |
|----------------------------------------------------------------------------|
| slt Rdest, Rsrc1, Src2 | Positionner si < (5) | pseudo si Src2=Imm |
|----------------------------------------------------------------------------|
| sltu Rdest, Rsrc1, Src2 | Positionner si < non signé | pseudo si Src2=Imm |
| | (5) | |
|----------------------------------------------------------------------------|
| slti Rdest, Rsrc1, Imm | Positionner si < à l'Imm | pseudo si Imm sur |
| | (5) | plus de 16 bits | |
|----------------------------------------------------------------------------|
| sltiu Rdest, Rsrc1, Imm | Positionner si < non signé | pseudo si Imm sur |
| | à l'Imm (5) | plus de 16 bits |
|----------------------------------------------------------------------------|
| sne Rdest, Rsrc1, Src2 | Positionner si != (6) | pseudo-instruction |
|----------------------------------------------------------------------------|
(1) Positionne le registre Rdest à 1 si Rsrc1 = Src2 ; 0 sinon
(2) Positionne le registre Rdest à 1 si Rsrc1 >= Src2 ; 0 sinon
(3) Positionne le registre Rdest à 1 si Rsrc1 > Src2 ; 0 sinon
(4) Positionne le registre Rdest à 1 si Rsrc1 <= Src2 ; 0 sinon
(5) Positionne le registre Rdest à 1 si Rsrc1 < Src2 ; 0 sinon
(6) Positionne le registre Rdest à 1 si Rsrc1 != Src2 ; 0 sinon
2.5.4 - Instructions de branchement et de saut
Les instructions de branchement utilisent dans
l'einstruction un champ de décalage signé de 16 bits; elles
peuvent donc effectuer un saut de 2^15 -1 instructions vers
l'avant ou de 2^15 instructions vers l'arrière. Dans les
descriptions, les décalages ne sont pas spécifiés. au lieu
de cela, les instructions effectuent un branchement sur une
étiquette. C'est la forme utilisée dabs le plupart des
programmes en langage assembleur car la distance entre les
instructions est difficile à calculer à cause de l'expansion
des pseudo-instructions en plusieurs instructions réelles.
|----------------------------------------------------------------------------|
| Syntaxe | Description | Commentaires |
|----------------------------------------------------------------------------|
| b label | branchement inconditionnel | pseudo-instruction |
|----------------------------------------------------------------------------|
| beq Rsrc1, Src2, label | branchement si = | pseudo si Src2=Imm |
|----------------------------------------------------------------------------|
| beqz Rsrc1, label | branchement si = 0 | pseudo-instruction |
|----------------------------------------------------------------------------|
| bge Rsrc1, Src2, label | branchement si >= | pseudo si Src2=Imm |
|----------------------------------------------------------------------------|
| bgeu Rsrc1, Src2, label | branchement si >=, non | pseudo-instruction |
| | signé | |
|----------------------------------------------------------------------------|
| bgez Rsrc1, label | branchement si >= 0 | |
|----------------------------------------------------------------------------|
| bgezal Rsrc1, label | branchement si >= 0, avec | |
| | lien (1) | |
|----------------------------------------------------------------------------|
| bgt Rsrc1, Src2, label | branchement si > | pseudo si Src2=Imm |
|----------------------------------------------------------------------------|
| bgtu Rsrc1, Src2, label | branchement si > , non | pseudo-instruction |
| | signé | |
|----------------------------------------------------------------------------|
| bgtz Rsrc1, label | branchement si > 0 | |
|----------------------------------------------------------------------------|
| bgtzal Rsrc1, label | branchement si > 0, avec | |
| | lien (1) | |
|----------------------------------------------------------------------------|
| ble Rsrc1, Src2, label | branchement si <= | pseudo si Src2=Imm |
|----------------------------------------------------------------------------|
| bleu Rsrc1, Src2, label | branchement si <=, non | pseudo-instruction |
| | signé | |
|----------------------------------------------------------------------------|
| blez Rsrc1, label | branchement si <= 0 | |
|----------------------------------------------------------------------------|
| blezal Rsrc1, label | branchement si <= 0, avec | |
| | lien (1) | |
|----------------------------------------------------------------------------|
| blt Rsrc1, Src2, label | branchement si < | pseudo si Src2=Imm |
|----------------------------------------------------------------------------|
| bltu Rsrc1, Src2, label | branchement si < , non | pseudo-instruction |
| | signé | |
|----------------------------------------------------------------------------|
| bltz Rsrc1, label | branchement si < 0 | |
|----------------------------------------------------------------------------|
| bltzal Rsrc1, label | branchement si < 0, avec | |
| | lien (1) | |
|----------------------------------------------------------------------------|
| bne Rsrc1, Src2, label | branchement si != | pseudo si Src2=Imm |
|----------------------------------------------------------------------------|
| bnez Rsrc1, label | branchement si != 0 | pseudo-instruction |
|----------------------------------------------------------------------------|
| j label | saut inconditionnel | |
|----------------------------------------------------------------------------|
| jal label | saut inconditionnel avec | |
| | lien (1) | |
|----------------------------------------------------------------------------|
| jalr Rsrc1 | saut inconditionnel avec | |
| | lien par registre (2) | |
|----------------------------------------------------------------------------|
| jr Rsrc1 | saut inconditionnel par | |
| | registre (2) | |
|----------------------------------------------------------------------------|
(1) Sauvegarde l'adresse de l'instruction suivante dans le registre 31
(2) L'adressse de l'instruction vers laquelle le saut est réalisé se trouve
dans le registre Rsrc1
2.5.5 - Instructions d'accès à la mémoire
|-----------------------------------------------------------------------------|
| Syntaxe | Description | Commentaires |
|-----------------------------------------------------------------------------|
| la Rdest, address | chargement d'adresse (1) | pseudo-instruction |
|-----------------------------------------------------------------------------|
| lb Rdest, address | chargement d'un octet (2) | |
|-----------------------------------------------------------------------------|
| lbu Rdest, address | chargement d'un octet ns (3) | pseudo-instruction |
|-----------------------------------------------------------------------------|
| ld Rdest, address | chargement d'un mot double(4)| |
|-----------------------------------------------------------------------------|
| lh Rdest, address | chargement d'un 1/2-mot (2) | |
|-----------------------------------------------------------------------------|
| lhu Rdest, address | chargement d'un 1/2-mot ns(3)| |
|-----------------------------------------------------------------------------|
| lw Rdest, address | chargement d'un mot | |
|-----------------------------------------------------------------------------|
| lwl Rdest, address | chargement de la partie | |
| | gauche d'un mot (5) | |
|-----------------------------------------------------------------------------|
| lwr Rdest, address | chargement de la partie | |
| | droite d'un mot (5) | |
|-----------------------------------------------------------------------------|
| sb Rdest, address | rangement d'un octet (6) | |
|-----------------------------------------------------------------------------|
| sd Rdest, address | rangement d'un mot double (7)| |
|-----------------------------------------------------------------------------|
| sh Rdest, address | rangement d'un 1/2-mot (6) | |
|-----------------------------------------------------------------------------|
| sw Rdest, address | rangement d'un mot | |
|-----------------------------------------------------------------------------|
| swl Rdest, address | rangement de la partie | |
| | gauche d'un mot (5) | |
|-----------------------------------------------------------------------------|
| swr Rdest, address | rangement de la partie | |
| | droite d'un mot (5) | |
|-----------------------------------------------------------------------------|
| ulh Rdest, address | chargement non-aligné d'un | |
| | 1/2 mot (2) | pseudo-instruction |
|-----------------------------------------------------------------------------|
| ulhu Rdest, address | chargement non-aligné d'un | |
| | 1/2 mot non-signé (3) | pseudo-instruction |
|-----------------------------------------------------------------------------|
| ulw Rdest, address | chargement non-aligné d'un | |
| | mot | pseudo-instruction |
|-----------------------------------------------------------------------------|
| ush Rdest, address | rangement non-aligné d'un | |
| | 1/2 mot (6) | pseudo-instruction |
|-----------------------------------------------------------------------------|
| usw Rdest, address | rangement non-aligné d'un | |
| | mot | pseudo-instruction |
|-----------------------------------------------------------------------------|
(1) Chargement de l'adresse calculée, et non le contenu de l'emplacement mémoire
à cette adresse, dans le registre Rdest
(2) Extension par le signe
(3) Extension par zéro
(4) Les 64 bits sont chargés dans Rdest et Rdest+1
(5) L'adresse peut ne pas être alignée
(6) Poids faibles du registre
(7) Les 64 bits sont rangés dans Rdest et Rdest+1
2.5.6 - Instructions de transfert de données
|-----------------------------------------------------------------------------|
| Syntaxe | Description | Commentaires |
|-----------------------------------------------------------------------------|
| move Rdest, Rsrc1 | transfert de registre | pseudo-instruction |
|-----------------------------------------------------------------------------|
| mfhi Rdest | transfert depuis hi | |
|-----------------------------------------------------------------------------|
| mflo Rdest | transfert depuis lo | |
|-----------------------------------------------------------------------------|
| mthi Rdest | transfert vers hi | |
|-----------------------------------------------------------------------------|
| mtlo Rdest | transfert vers lo | |
|-----------------------------------------------------------------------------|
* les registres hi et lo sont utilisés lors de multiplication et division
2.5.7 - Instructions flottantes
Le mips a un coprocesseur flottant qui opère sur des nombres
flottants simple précision (32 bits) et double précision (64
bits). Ce coprocesseur dispose de ses propres registres, qui
sont numérotés
$fo-$f31
. Puisque ces registres n'ont que 32 bits de large, il en
faut 2 pour le nombres double précision. Pour simplifier les
opérations flottantes, même les opérations simple précision
n'utilisent que des registres de numéro pair. Dans le
instructions suivantes,
FRdest
,
FRsrc1
,
FRsrc2
et
Frsrc
sont des registres du coprocesseur flottant.
|----------------------------------------------------------------|
| Syntaxe | Description |
|----------------------------------------------------------------|
| abs.d FRdest, FRsrc | valeur asolue flottante double |
|----------------------------------------------------------------|
| abs.s FRdest, FRsrc | valeur asolue flottante simple |
|----------------------------------------------------------------|
| add.d FRdest, FRsrc1, FRsrc2 | addition flottante double |
|----------------------------------------------------------------|
| add.s FRdest, FRsrc1, FRsrc2 | addition flottante simple |
|----------------------------------------------------------------|
| c.eq.d FRsrc1, FRsrc2 | test si égalité double |
|----------------------------------------------------------------|
| c.eq.s FRsrc1, FRsrc2 | test si égalité simple |
|----------------------------------------------------------------|
| c.le.d FRsrc1, FRsrc2 | test si <= double |
|----------------------------------------------------------------|
| c.le.s FRsrc1, FRsrc2 | test si <= simple |
|----------------------------------------------------------------|
| c.lt.d FRsrc1, FRsrc2 | test si < double |
|----------------------------------------------------------------|
| c.lt.s FRsrc1, FRsrc2 | test si < simple |
|----------------------------------------------------------------|
| cvt.d.s FRdest, FRsrc | conversion simple en double |
|----------------------------------------------------------------|
| cvt.d.w FRdest, FRsrc | conversion entier en double |
|----------------------------------------------------------------|
| cvt.s.d FRdest, FRsrc | conversion double en simple |
|----------------------------------------------------------------|
| cvt.s.w FRdest, FRsrc | conversion entier en simple |
|----------------------------------------------------------------|
| cvt.w.d FRdest, FRsrc | conversion double en entier |
|----------------------------------------------------------------|
| cvt.w.s FRdest, FRsrc | conversion simple en entier |
|----------------------------------------------------------------|
| div.d FRdest, FRsrc1, FRsrc2 | division flottante double (1) |
|----------------------------------------------------------------|
| div.s FRdest, FRsrc1, FRsrc2 | division flottante simple (1) |
|----------------------------------------------------------------|
| l.d FRdest, address | chargement flottant double |
|----------------------------------------------------------------|
| l.s FRdest, address | chargement flottant simple |
|----------------------------------------------------------------|
| mov.d FRdest, FRsrc | transfert flottant double |
|----------------------------------------------------------------|
| mov.s FRdest, FRsrc | transfert flottant simple |
|----------------------------------------------------------------|
| mul.d FRdest, FRsrc1, FRsrc2 | multiplication flottante double |
|----------------------------------------------------------------|
| mul.s FRdest, FRsrc1, FRsrc2 | multiplication flottante simple |
|----------------------------------------------------------------|
| neg.d FRdest, FRsrc | opposé flottant double |
|----------------------------------------------------------------|
| neg.s FRdest, FRsrc | opposé flottant simple |
|----------------------------------------------------------------|
| s.d FRdest, address | rangement flottant double |
|----------------------------------------------------------------|
| s.s FRdest, address | rangement flottant simple |
|----------------------------------------------------------------|
| sub.d FRdest, FRsrc1, FRsrc2 | soustraction flottante double |
|----------------------------------------------------------------|
| sub.s FRdest, FRsrc1, FRsrc2 | soustraction flottante simple |
|----------------------------------------------------------------|
(1) Calcul le quotient des nombres contenus dans FRsrc1 et FRsrc2
et le place dans FRdest
2.5.8 - Instructions d'interruption
|----------------------------------|
| Syntaxe | Description |
|----------------------------------|
| syscall | appel système (1) |
|----------------------------------|
| nop | ne rien faire |
|----------------------------------|
(1) voir section 2.3
2.5.9 - Les registres SPIM
|-------------------------------------------------------------------------------|
| Nom | N° | Usage || Nom | N° | Usage || Nom | N° | Usage |
|-----------------------||-----------------------||-----------------------------|
|zero | 0 | cste 0 || t3 | 11 | temporaire || s6 | 22 | sauvegardé |
|-----------------------||-----------------------||-----------------------------|
| at | 1 | réservé || t4 | 12 | temporaire || s7 | 23 | sauvegardé |
|-----------------------||-----------------------||-----------------------------|
| r0 | 2 | résultat || t5 | 13 | temporaire || t8 | 22 | temporaire |
|-----------------------||-----------------------||-----------------------------|
| r1 | 3 | résultat || t6 | 14 | temporaire || t9 | 22 | temporaire |
|-----------------------||-----------------------||-----------------------------|
| a0 | 4 | argument 1 || t7 | 15 | temporaire || k0 | 22 | réservé |
|-----------------------||-----------------------||-----------------------------|
| a1 | 5 | argument 2 || s0 | 16 | sauvegardé || k1 | 22 | réservé |
|-----------------------||-----------------------||-----------------------------|
| a2 | 6 | argument 3 || s1 | 17 | sauvegardé || gp | 22 | global pointer |
|-----------------------||-----------------------||-----------------------------|
| a3 | 7 | argument 4 || s2 | 18 | sauvegardé || sp | 22 | pointeur de pile |
|-----------------------||-----------------------||-----------------------------|
| t0 | 8 | temporaire || s3 | 19 | sauvegardé || fp | 22 | pointeur de bloc |
|-----------------------||-----------------------||-----------------------------|
| t1 | 9 | temporaire || s4 | 20 | sauvegardé || ra | 22 | adresse de retour|
|-----------------------||-----------------------||-----------------------------|
| t2 | 10 | temporaire || s5 | 21 | sauvegardé || | | |
|-------------------------------------------------------------------------------|
2.6 - Modes d'adressage
MIPS est une architecture de type chargement/rangement, ce qui
signifie que seule les instructions de chargement/rangement
accèdent à la mémoire. La machine brute ne fournit qu'un seul
mode d'adressage de la mémoire :
c(rx)
, qui utilise comme adresse la somme de l'immédiat
c
et du contenu du registre
rx
. La machine virtuelle fournit les modes d'adressage suivants
pour les instructions de chargement/rangement :
|--------------------------------------------------------------------------|
| Format | Caclul d'adresse |
|--------------------------------------------------------------------------|
| (registre) | adresse = contenu du registre |
|--------------------------------------------------------------------------|
| imm | adresse = immédiat |
|--------------------------------------------------------------------------|
| imm(registre) | adresse = immédiat + contenu du registre |
|--------------------------------------------------------------------------|
| symbole | adresse = adresse du symbole |
|--------------------------------------------------------------------------|
| symbole +/- imm | adresse = adresse du symbole + ou - immédiat |
|--------------------------------------------------------------------------|
| symbole +/- imm(registre) | adresse = adresse du symbole + ou - |
| | (immédiat + contenu du registre) |
|--------------------------------------------------------------------------|
© Université de Marne-la-Vallée