mips Tutoriel
Commencer avec mips
Recherche…
Remarques
Cette section fournit une vue d'ensemble de ce qu'est le mips et de la raison pour laquelle un développeur peut vouloir l'utiliser.
Il devrait également mentionner tous les grands sujets dans les mips, et établir un lien avec les sujets connexes. La documentation pour mips étant nouvelle, vous devrez peut-être créer des versions initiales de ces rubriques connexes.
Installation ou configuration
Instructions détaillées sur l'installation ou l'installation de Mips.
QtSpim pour windows
- téléchargez QtSpim à partir d' ici 32.6 MB
- installez-le facilement
- Créez votre premier fichier d'assemblage (.s) ou utilisez l'exemple C: \ Program Files (x86) \ QtSpim \ helloworld.s
- exécuter le programme à partir du raccourci du bureau ou de C: \ Program Files (x86) \ QtSpim \ QtSpim.exe
il y a deux fenêtres pour le programme, la principale appelé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ées FP Reg pour les virgules flottantes et Int Reg et le contrôle du simulateur
l'autre console étiquetée console est l'endroit où vous verrez la sortie et entrez l'entrée de votre programme s'il y en a
- charger le fichier en utilisant File -> Load File
- vous pouvez utiliser click run (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 que le programme s'exécute pour déboguer
Simulateur MARS MIPS
Le simulateur MARS MIPS est un éditeur, assembleur, simulateur et débogueur de langage d'assemblage pour le processeur MIPS, développé par Pete Sanderson et Kenneth Vollmar à la Missouri State University ( src ).
Vous obtenez le MARS gratuitement ici . Comme pour l'installation de la version 4.5, vous pourriez avoir besoin du SDK Java adapté à votre système à partir d' ici
Avant l'assemblage, l'environnement de ce simulateur peut être divisé en trois segments: l' éditeur en haut à gauche où tout le code est écrit, le compilateur / la sortie juste sous l'éditeur et la liste des registres qui représentent le "CPU" pour notre programme.
Après l'assemblage (en appuyant simplement sur F3), l'environnement change, avec deux nouveaux segments obtenant la position de l'éditeur: le segment de texte où
i) chaque ligne de code d'assemblage est débarrassée des "pseudoinstructions" (nous en parlerons en une seconde) à la colonne "basique" et
ii) le code machine pour chaque instruction dans la colonne "code",
et le segment de données où l'on peut regarder une représentation de la mémoire d'un processeur avec un ordre peu endian .
Après assemblage, nous pouvons exécuter notre code en une seule fois (F5) ou pas à pas (F7), et rembobiner plusieurs fois l’exécution vers l’arrière (F8).
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 personnage, qu'en est-il du bon vieux "Hello World"? Qu'en est-il, dunno, ajouter un numéro ou quelque chose? Eh bien, nous pouvons changer ce que nous avions un peu pour cela:
.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, un peu plus d'explications sur ces commandes est nécessaire:
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 placé dans $ v0 register pour l'opération requise. Si un appel système a des arguments, ceux-ci sont placés dans les registres $ a0- $ a2. Voici tous les appels système.
li
(load immediate) est une pseudo-instruction (nous en reparlerons plus tard) qui charge instantanément un registre avec une valeur.la
(load address) est aussi une pseudo-instruction qui charge une adresse dans un registre. Avecli $v0, 4
le registre $ v0 a maintenant4
comme valeur, tandis quela $a0, str
charge la chaîne destr
dans le registre$a0
.Un mot est (autant que nous parlons de MIPS) une séquence de 32 bits, 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 à un registre, tandis quesw
(mot de stockage) est transféré d'un registre à la mémoire. Avec la commandelw $s1, 0($t0)
, nous avons chargé dans$s1
la valeur qui était au LSB du registre$t0
(ce que le0
symbolise ici, le décalage du mot), aka256
.$t0
ici l'adresse, alors que$s1
a la valeur.sw $t2, 0($t0)
fait juste le travail opposé.MARS utilise le Little Endian , 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 de la suivante 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:
ou activer "ASCII" à partir du segment de données:
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 Exécuter. Maintenant, vous commencez à compiler et à exécuter du code MIPS.