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

  1. téléchargez QtSpim à partir d' ici 32.6 MB
  2. installez-le facilement
  3. Créez votre premier fichier d'assemblage (.s) ou utilisez l'exemple C: \ Program Files (x86) \ QtSpim \ helloworld.s
  4. 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

  1. charger le fichier en utilisant File -> Load File
  2. 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. entrer la description de l'image ici

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

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 . entrer la description de l'image ici

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). entrer la description de l'image ici

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. 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) 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 que sw (mot de stockage) est transféré d'un registre à la mémoire. Avec la commande lw $s1, 0($t0) , nous avons chargé dans $s1 la valeur qui était au LSB du registre $t0 (ce que le 0 symbolise ici, le décalage du mot), aka 256 . $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:

entrer la description de l'image ici

ou activer "ASCII" à partir du segment de données:

entrer la description de l'image ici

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.



Modified text is an extract of the original Stack Overflow Documentation
Sous licence CC BY-SA 3.0
Non affilié à Stack Overflow