mips Handledning
Komma igång med mips

Anmärkningar

Installation eller installation

Detaljerade anvisningar om hur du installerar eller installerar möss.

QtSpim för windows

1. ladda ner QtSpim härifrån 32,6 MB
2. installera det enkelt installation
3. skapa din första monteringsfil (.s) eller använd exemplet C: \ Program Files (x86) \ QtSpim \ helloworld.s
4. kör programmet från skrivbordsgenvägen eller C: \ Program Files (x86) \ QtSpim \ QtSpim.exe

det finns två fönster för programmet, det huvudsakliga märkt QtSpim här ser du programmet du kör (märkt text), minnet (märkta data), värdena på registren (märkta FP Regs för flytande punkt och Int Regs för heltal) och kontrollen för simulatorn

det andra fönstret märkta konsolen är där du kommer att se utgången och ange ingången till ditt program om det finns några

5. ladda filen med File -> Load File
6. du kan använda klickkörning (f5) för att se slutresultatet eller gå steg för steg (p10) för att se status för registret och minnet medan programmet kör till felsökning

MARS MIPS Simulator

MARS MIPS-simulator är en redaktör, assembler, simulator & debugger för montagespråk för MIPS-processorn, utvecklad av Pete Sanderson och Kenneth Vollmar vid Missouri State University ( src ).

Du får MARS gratis här . När det gäller installation av 4.5-versionen kan du behöva lämplig Java SDK för ditt system härifrån

Innan montering kan simulatorns miljö enkelt delas upp i tre segment: redigeraren längst upp till vänster där hela koden skrivs, kompilatorn / utgången precis under redigeraren och listan med register som representerar "CPU" för vårt program.

Efter montering (genom att helt enkelt trycka på F3) förändras miljön, med två nya segment som får redaktörens position: textsegmentet där

i) varje rad i monteringskoden rensas från "pseudoinstruktioner" (vi kommer att prata om de i ett sekund) i den "grundläggande" kolumnen och

ii) maskinkoden för varje instruktion i kolumnen "kod",

och datasegmentet där vi kan titta på en representation av minnet för en processor med liten endianordning .

Efter montering kan vi köra vår kod antingen samtidigt (F5) eller steg för steg (F7), liksom att spola tillbaka exekveringen flera steg bakåt till baksidan (F8).

Låt oss nu se exempelkoden ovanifrån och förklara varje rad:

.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 accepterar och exporterar filer med filtypen .asm

Men koden ovan skriver bara en karaktär, hur är det med den goda "Hello World"? Vad sägs om, vet inte, lägga till ett nummer eller något? Vi kan ändra vad vi hade lite för just det:

.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 

Innan resultaten illustreras genom MARS behövs lite mer förklaring om dessa kommandon:

• Systemsamtal är en uppsättning tjänster som tillhandahålls från operativsystemet. För att använda ett systemsamtal krävs en samtalskod för att läggas till $ v0-register för den nödvändiga operationen. Om ett systemsamtal har argument placeras de i $ a0- $ a2-register. Här är alla systemsamtal.

• li (ladda omedelbart) är en pseudoinstruktion (vi kommer att prata om det senare) som omedelbart laddar ett register med ett värde. la (lastadress) är också en pseudoinstruktion som laddar en adress till ett register. Med li $v0, 4 har $ v0-registret nu 4 som värde, medan la $a0, str laddar strängen av str till $a0 registret.

• Ett ord är (så mycket som vi talar om MIPS) en sekvens med 32 bitar, där bit 31 är den mest betydelsefulla biten och bit 0 är den minst betydande biten.

• lw (ladda ord) överför från minnet till ett register, medan sw (lagra ord) överför från ett register till minnet. Med lw $s1, 0($t0) laddade vi till $s1 registrerar värdet som var vid LSB i $t0 registret (det är det 0 symboliserar här, kompensationen av ordet), alias 256 . $t0 här har adressen, medan $s1 har värdet. sw $t2, 0($t0) gör precis det motsatta jobbet.

• MARS använder Little Endian , vilket innebär att LSB för ett ord lagras till minnets minsta bitadress.

• MIPS använder byte-adresser , så en adress skiljer sig från dess föregående och nästa av 4.

Genom att sätta ihop koden från tidigare kan vi ytterligare förstå hur minne och register utbyter, inaktivera "Hexadecimala värden" från datasegmentet:

eller aktivera "ASCII" från datasegmentet:

Börja det så här

$ java -jar Mars4_5.jar

Skapa den här filen och spara den.

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

Tryck på F3 för att montera den och tryck sedan på Kör. Nu har du börjat sammanställa och köra MIPS-kod.