Débuter avec les mips

Simulateur MARS MIPS

Le simulateur MARS MIPS est un éditeur de langage d’assemblage, un assembleur, un simulateur et un débogueur pour le processeur MIPS, développé par Pete Sanderson et Kenneth Vollmar de la Missouri State University ([src][1]).

Vous obtenez le MARS gratuitement [ici][2]. En ce qui concerne l’installation de la version 4.5, vous aurez peut-être besoin du SDK Java adapté à votre système à partir de [ici][3]

Avant l’assemblage, l’environnement de ce simulateur peut être simplement divisé en trois segments : l’éditeur en haut à gauche où tout le code est écrit, le compilateur/sortie juste en dessous de l’éditeur et la liste des registres qui représentent le “CPU” de notre programme. [![entrez la description de l’image ici][4]][4]

Après assemblage (en appuyant simplement sur F3) l’environnement change, avec deux nouveaux segments prenant la position de l’éditeur : le segment de texte où

i) chaque ligne de code assembleur est débarrassée des “pseudo-instructions” (nous en reparlerons dans une seconde) dans la colonne “de base” et

ii) le code machine de chaque instruction dans la colonne “code”,

et le segment de données où l’on peut voir une représentation de la mémoire d’un processeur avec [ordre petit-boutiste][5]. [![entrez la description de l’image ici][6]][6]

Après assemblage, nous pouvons exécuter notre code soit en une seule fois (F5) soit pas à pas (F7), ainsi que rembobiner l’exécution plusieurs pas en arrière (F8). [![entrez la description de l’image ici][7]][7]

Voyons maintenant l’exemple de code ci-dessus et expliquons chaque ligne :

.text
.globl main
main:            #main function

li    $v0, 11    #11=system code for printing a character, $v0=register that gets the system code for printing as value
la    $a0, 'a'   #'a'=our example character, $a0=register that accepts the character for printing
syscall          #Call to the System to execute our instructions and print the character at the a0 register 

li $v0, 10       #11=system code for terminating, $v0=register that gets the system code for terminating (optional, but desirable)
syscall          #Call to the System to terminate the execution

MARS accepte et exporte les fichiers avec le type de fichier .asm

Mais le code ci-dessus imprime juste un caractère, qu’en est-il du bon vieux “Hello World” ? Qu’en est-il, je ne sais pas, d’ajouter un chiffre ou quelque chose ? Eh bien, nous pouvons changer un peu ce que nous avions juste pour ça :

.data               #data section 
str: .asciiz "Hello world\n"  
number: .word 256
 
.text                 #code section 
.globl main 
main: 
li       $v0, 4                #system call for printing strings 
la       $a0, str              #loading our string from data section to the $a0 register
syscall  
       
la       $t0, number        #loading our number from data section to the $t0 register
lw       $s1, 0($t0)        #loading our number as a word to another register, $s1 

addi     $t2, $s1, 8         #adding our number ($s1) with 8 and leaving the sum to register $t2

sw       $t2, 0($t0)        #storing the sum of register $t2 as a word at the first place of $t0

li       $v0, 10               # system call for terminating the execution
syscall

Avant d’illustrer les résultats via MARS, quelques explications supplémentaires sur ces commandes sont nécessaires :

  • Les appels système sont un ensemble de services fournis par le système d’exploitation. Pour utiliser un appel système, un code d’appel doit être mis à $v0 s’enregistre pour l’opération nécessaire. Si un appel système a arguments, ceux-ci sont placés dans les registres $a0-$a2. [Ici][8] sont tous les appels système.

  • li (chargement immédiat) est une pseudo-instruction (on en reparlera plus tard) qui charge instantanément un registre avec une valeur. la (charge adresse) est également une pseudo-instruction qui charge une adresse dans un S’inscrire. Avec li $v0, 4 le registre $v0 a maintenant 4 comme valeur, tandis que la $a0, str charge la chaîne de str dans le Registre $a0.

  • Un mot est (autant que nous parlons de MIPS) un 32 bits séquence, le bit 31 étant le bit le plus significatif et le bit 0 étant le bit le moins significatif.

  • lw (mot de chargement) transfère de la mémoire vers un registre, tandis que sw (mot de stockage) transferts d’un registre vers la mémoire. Avec le lw $s1, 0($t0), nous avons chargé dans le registre $s1 la valeur qui était au LSB du registre $t0 (c’est ce que le 0 symbolise ici, le décalage du mot), alias “256”. $t0 a ici l’adresse, tandis que $s1 a la valeur. sw $t2, 0($t0) fait exactement le contraire travail.

  • MARS utilise le [Little Endian][5], ce qui signifie que le LSB d’un mot est stocké à la plus petite adresse d’octet de la mémoire.

  • MIPS utilise des adresses d’octets, donc une adresse est séparée de sa précédente et ensuite par 4.

En assemblant le code d’avant, nous pouvons mieux comprendre comment la mémoire et les registres s’échangent, en désactivant les “valeurs hexadécimales” du segment de données :

[![entrez la description de l’image ici][9]][9]

ou en activant “ASCII” depuis le segment de données :

[![entrez la description de l’image ici][10]][10]

Commencez comme ça

$ java -jar Mars4_5.jar

Créez ce fichier et enregistrez-le.

    .text
main:
    li    $s0,0x30
loop:
    move    $a0,$s0        # copy from s0 to a0
    
    li    $v0,11        # syscall with v0 = 11 will print out
    syscall            # one byte from a0 to the Run I/O window

    addi    $s0,$s0,3    # what happens if the constant is changed?
    
    li    $t0,0x5d
    bne    $s0,$t0,loop
    nop            # delay slot filler (just in case)

stop:    j    stop        # loop forever here
    nop            # delay slot filler (just in case)

Appuyez sur F3 pour l’assembler, puis appuyez sur run. Vous commencez maintenant à compiler et à exécuter le code MIPS.

[1] : https://www.d.umn.edu/~gshute/mips/Mars/Mars.xhtml [2] : http://courses.missouristate.edu/kenvollmar/mars/ [3] : http://www.oracle.com/technetwork/java/javase/downloads/jdk8-downloads-2133151.html [4] : https://i.stack.imgur.com/tk0uJ.png [5] : https://en.wikipedia.org/wiki/Endianness [6] : https://i.stack.imgur.com/Qr0Q0.png [7] : https://i.stack.imgur.com/4wact.png [8] : https://courses.missouristate.edu/KenVollmar/mars/Help/SyscallHelp.html [9] : https://i.stack.imgur.com/d72j5.png [10] : https://i.stack.imgur.com/LpDSz.png

Installation ou configuration

Instructions détaillées sur la configuration ou l’installation de mips.

QtSpim pour Windows

  1. téléchargez QtSpim depuis [ici][1] 32,6 Mo
  2. installez-le installation facile
  3. créez votre premier fichier d’assemblage (.s) ou utilisez l’exemple C:\Program Files (x86)\QtSpim\helloworld.s
  4. Exécutez le programme à partir du raccourci sur le bureau ou C:\Program Files (x86)\QtSpim\QtSpim.exe

il y a deux fenêtres pour le programme la principale étiquetée QtSpim ici vous voyez le programme que vous exécutez (texte étiqueté), la mémoire (données étiquetées), les valeurs des registres (étiquetés FP Regs pour virgule flottante et Int Regs pour entier ) et le contrôle du simulateur

l’autre fenêtre intitulée console est l’endroit où vous verrez la sortie et entrez l’entrée de votre programme s’il y en a

  1. chargez le fichier en utilisant Fichier -> Charger le fichier
  2. vous pouvez utiliser cliquer sur exécuter (f5) pour voir le résultat final ou aller étape par étape (p10) pour voir l’état du registre et de la mémoire pendant l’exécution du programme pour déboguer

[1] : https://sourceforge.net/projects/spimsimulator/files/