:: Enseignements :: Licence :: L3 :: 2007-2008 :: Architecture des ordinateurs ::
[LOGO]

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 :

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) |
|--------------------------------------------------------------------------|