mips Tutorial
Iniziare con i mips

Osservazioni

Installazione o configurazione

Istruzioni dettagliate su come installare o installare i mips.

QtSpim per Windows

1. scarica QtSpim da qui 32.6 MB
2. installarlo facile installazione
3. crea il tuo primo file assembly (.s) o usa l'esempio C: \ Programmi (x86) \ QtSpim \ helloworld.s
4. eseguire il programma dal collegamento sul desktop o C: \ Programmi (x86) \ QtSpim \ QtSpim.exe

ci sono due finestre per il programma quella principale con etichetta QtSpim qui vedi il programma che stai eseguendo (testo etichettato), la memoria (dati etichettati), i valori dei registri (etichettati FP Regs per floating point e Int Regs per interi) e il controllo per il simulatore

l'altra finestra con l'etichetta console è dove vedrai l'output e inserisci l'input del tuo programma se ce ne sono

5. caricare il file usando File -> Carica file
6. puoi usare click run (f5) per vedere il risultato finale o andare passo dopo passo (p10) per vedere lo stato del registro e della memoria mentre il programma sta eseguendo il debug

MARS MIPS Simulator

Il simulatore MARS MIPS è un editor di linguaggio assembly, assemblatore, simulatore e debugger per il processore MIPS, sviluppato da Pete Sanderson e Kenneth Vollmar presso la Missouri State University ( src ).

Ottieni il MARS gratuitamente qui . Per quanto riguarda l'installazione della versione 4.5, potrebbe essere necessario l'opportuno SDK Java per il sistema da qui

Prima di assemblare, l'ambiente di questo simulatore può essere suddiviso in modo semplicistico su tre segmenti: l' editor in alto a sinistra in cui viene scritto tutto il codice, il compilatore / l'output subito sotto l'editor e l' elenco di registri che rappresentano la "CPU" per il nostro programma.

Dopo aver assemblato (semplicemente premendo F3) l'ambiente cambia, con due nuovi segmenti che ottengono la posizione dell'editor: il segmento di testo dove

i) ogni riga del codice assembly viene cancellata da "pseudoinstructions" (ne parleremo in un secondo) nella colonna "basic" e

ii) il codice macchina per ogni istruzione nella colonna "codice",

e il segmento di dati in cui possiamo dare un'occhiata a una rappresentazione della memoria di un processore con un ordine little-endian .

Dopo il montaggio, possiamo eseguire il nostro codice sia in una volta (F5) o passo dopo passo (F7), sia riavvolgendo l'esecuzione di diversi passi indietro (F8).

Ora, vediamo il codice di esempio sopra e spiega ogni riga:

.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 accetta ed esporta file con il filetype .asm

Ma il codice sopra mostra solo un personaggio, e il buon vecchio "Hello World"? Che dire, non so, aggiungendo un numero o qualcosa? Bene, possiamo cambiare quello che avevamo un po 'solo per quello:

.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 

Prima di illustrare i risultati tramite MARS, è necessario un po 'più di spiegazione su questi comandi:

• Le chiamate di sistema sono un insieme di servizi forniti dal sistema operativo. Per utilizzare una chiamata di sistema, è necessario un codice di chiamata da registrare su $ v0 per l'operazione richiesta. Se una chiamata di sistema ha argomenti, questi vengono messi nei registri $ a0- $ a2. Ecco tutte le chiamate di sistema.

• li (load immediate) è una pseudo-istruzione (ne parleremo più avanti) che carica istantaneamente un registro con un valore. la (load address) è anche una pseudo-istruzione che carica un indirizzo in un registro. Con li $v0, 4 il registro $ v0 ora ha 4 come valore, mentre la $a0, str carica la stringa di str nel registro $a0 .

• Una parola è (tanto quanto si parla di MIPS) una sequenza di 32 bit, con il bit 31 che è il bit più significativo e il bit 0 è il bit meno significativo.

• lw (load word) trasferisce dalla memoria ad un registro, mentre sw (store word) trasferisce da un registro alla memoria. Con il comando lw $s1, 0($t0) , abbiamo caricato su $s1 il valore che era al LSB del registro $t0 (questo è ciò che lo 0 simboleggia qui, l'offset della parola), alias 256 . $t0 qui ha l'indirizzo, mentre $s1 ha il valore. sw $t2, 0($t0) fa esattamente il contrario.

• MARS utilizza Little Endian , ovvero l'LSB di una parola viene memorizzato nell'indirizzo di byte più piccolo della memoria.

• MIPS utilizza gli indirizzi di byte , quindi un indirizzo è a parte del suo precedente e successivo di 4.

Assemblando il codice da prima, possiamo capire meglio come si scambiano memoria e registri, disabilitando "valori esadecimali" dal segmento dati:

o abilitare "ASCII" dal segmento dati:

Inizia in questo modo

$ java -jar Mars4_5.jar

Crea questo file e salvalo.

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

Premere F3 per assemblarlo e quindi premere run. Ora inizia la compilazione e l'esecuzione del codice MIPS.