MIPS (CPU)

Van Wikipedia

MIPS is een processor ontworpen door John L. Hennessy. MIPS baseert zich op de RISC processor architectuur.

Inhoud

1 Geschiedenis
2 Gebruik
3 MIPS is een RISC computer
4 Pseudo-Ops
5 Adresseer methoden
6 De subroutine "Linkage" en Stacks
- 6.1 MIPS call- en returnfunctie
7 Bronnen en referenties

[bewerk] Geschiedenis

In 1984 verliet Hennessy de universiteit van Stanford om MIPS Computer Systems op te richten, waar hij dan ook zijn eerste MIPS processor ontwierp en openbaar maakte, de R2000. In 1988 kwam de verbeterde versie van dit model, de R3000. Beiden zijn 32-bit processoren. Later kwam er ook een 64-bit versie vrij, de R4000. Doordat SGI (Sillicon Graphics), een belangrijke klant, steeds betere processoren wilde, moest er kostelijk onderzoek gebeuren. De onderzoekskosten deden MIPS Computer Systems de das om en het bedrijf kwam in financiële moeilijkheden. SGI heeft het bedrijf dan overgekocht, zodat het onderzoek niet verloren zou gaan. Het bedrijf kreeg de naam MIPS Technologies en bestaat vandaag de dag nog steeds onder die naam.

[bewerk] Gebruik

De MIPS-processoren worden vaak gebruikt in embedded systemen. Maar ook in enkele spelcomputers wordt de MIPS-processor gebruikt.

[bewerk] MIPS is een RISC computer

De Reduced Instruction Set Computer (RISC) is een processor architectuur waarbij heel de instructieset dezelfde tijd nodig heeft om uitgevoerd te worden. Daaruit is de MIPS architectuur gegroeid.

[bewerk] MIPS geheugen

De bedoeling van het geheugen is om groepen bits op te slaan en die door te zenden wanneer ze worden opgevraagd. De meeste huidige computers slagen informatie op in meervouden van 8 bits (of 1 byte). Elke byte krijgt ook een numeriek adres toegewezen. De MIPS processor heeft een 32-bit-adresgrootte, beginnend van 0x00000000 tot 0xFFFFFFFF. In het geheugen kan je zowel programma-instructies als data opslagen. Dus één van de functies van een besturingssysteem is dat het stukken geheugen kan toewijzen aan instructies of data van elk proces. Het geheugen kan zowel als Little Endian en als Big Endian gebruikt worden. Little Endian is wanneer je de minst beduidende bit eerst in het geheugen plaatst. Big Endian is wanneer je de meest beduidende bit eerst in het geheugen plaatst.

[bewerk] MIPS instructieset

MIPS maakt gebruik van 32 verschillende registers. Hieronder een overzicht van de verschillende registers.

**Registers**
Naam	Nummer	Gebruik
$zero	$0	Blijft steeds 0
$at	$1	Voorbehouden voor de assembler
$v0–$v1	$2–$3	Geeft de resultaten van functies
$a0–$a3	$4–$7	Functie argumenten
$t0–$t7	$8–$15	Tijdelijke data
$s0–$s7	$16–$23	Opgeslagen tijdelijke data
$t8–$t9	$24–$25	Tijdelijke data
$k0–$k1	$26–$27	Voorbehouden voor de kernel van het besturingssysteem
$gp	$28	Globale pointer
$sp	$29	Stack pointer
$fp	$30	Frame pointer
$ra	$31	Terugkeeradres

MIPS instructies zijn 32 bit lang, zelfs bij de 64-bits processors. Dit zorgt voor een betere comptabiliteit met de 32-bit instructieset. Er is ook een mogelijkheid om via een extensie de processor een 16-bit instructieset te laten gebruiken. Dit wordt gebruikt wanneer de codelengte belangrijker is dan de performantie.

De MIPS instructieset architectuur is achterwaarts compatibel, dit wil zeggen dat een MIPS IV processor nog steeds een MIPS I code kan uitvoeren.

De MIPS is een load-store machine. De enige toegelaten geheugenoperaties zijn het laden van waarden in één van de registers of het opslaan van data vanuit een register in het geheugen.

Er zijn drie categorieën van instructies:

Laad en opslag
- Laad data van het geheugen in een register, of sla een registerinhoud op in het geheugen.
- Vb.: lw $t0, num1 #laad woord van num1 in register $t0

Wiskundige en logische bewerkingen
- Dit laat u toe om wiskundige en logische bewerkingen uit te voeren.
- Vb.: add $t0, $t3, $t4 # $t0 = $t3 + $t4

Jump en branch
- Wordt gebruikt om naar verschillende plaatsen in het programma te gaan.
- Vb.: bij het gebruik van een IF-instructie.

[bewerk] MIPS instructie formaten

MIPS heeft drie instructieformaten.

Type	-31- formaat (bits) -0-
R	opcode (6 bits)	rs (5 bits)	rt (5 bits	rd (5 bits)	shamt (5 bits)	funct (6 bits)
I	opcode (6 bits)	rs (5 bits)	rt (5 bits)	immediate (16 bits)
J	opcode (6 bits)	address (26 bits)

[bewerk] Pseudo-Ops

Hieronder zijn enkele “pseudo-ops” of pseudo-operaties beschreven. Ze zullen het gedrag van de assembler mee bepalen. Gewone opcodes zijn processor gebonden terwijl pseudo-ops specifiek bij een bepaalde assembler horen omdat ze door de assembler zelf worden uitgevoerd.

Pseudo-op	Beschrijving
.2byte expressie1[ , expressie2 ] … [ , expressieN]	Verkleint de expressies in de komma-gescheiden lijst (ook wel comma-separated list) naar 16-bits waarden en assembleert de waarden in overervende waarden. De expressies moeten absoluut zijn of, als de labels in dezelfde sectie zijn gedefinieerd, moeten ze gedefinieerd zijn in een verschil van labels(label1-label2). Deze richtlijn kan optioneel de vorm “expressie 1 [:expressie2] hebben. Wat betekent dat expressie 2 de waarde van expressie 1 twee keer kopieert. Deze richtlijn heeft geen automatische schikking (alleen maar 64-bit en N32)
.data	Zegt de assembler om alle volgende data bij de data sectie te zetten.
.end [proc_name]	Duidt het einde van een procedure aan. Gebruik deze verwijzing als je informatie wilt maken voor de debugger.

[bewerk] Adresseer methoden

Er zijn drie belangrijke manieren om naar data te verwijzen. Hieronder kan je zien hoe MIPS dit implementeert in zijn instructieformaten.

[bewerk] Direct

De bronoperatoren kunnen constanten zijn. Een constante waarde wordt dan ook direct in machinetaalinstructies geëncodeerd. Hierdoor is het adres onmiddellijk te bereiken nadat de instructie is gedecodeerd, zonder dat het adres uit het geheugen gehaald moet worden.

MIPS instructies vertalen directe constanten in de 16 minst beduidende bits van de directe instructie-layout. Indien de constante groter is dan 16 bits zullen er twee machine instructies worden gegenereerd. De meest beduidende cijfers worden dan geladen in het $at register met de “load upper immediate” instructie.

[bewerk] Register adressering

Door het gebruik van registers als bron en bestemming van data wordt de data sneller verwerkt dan bij het gebruik van geheugen. De meeste processoren hebben minstens één wiskundige instructieoperator nodig om register adressering te gebruiken. Instructies waarvan alle operators in registers zitten, zijn het snelst uit te voeren.

MIPS voorziet 32 registers en vraagt om gebruik te maken van deze registers om data te verwerken. Omdat je maar 5 bits (2^5 = 32) nodig hebt om naar een register te verwijzen, kan je gemakkelijk naar 3 registers verwijzen in een 32-bit instructie.

[bewerk] Geheugen adressering

Met 32-bit adressen kan een computer tot 4 GB geheugen toegang krijgen. Hierdoor kan je veel data opslaan, maar heb je ook meer tijd nodig om toegang te krijgen. In een MIPS instructie kan je maximum naar één geheugenadres verwijzen. Net zoals in de meeste supercomputers beperkt MIPS dit tot laad- en opslaginstructies.

[bewerk] De subroutine "Linkage" en Stacks

[bewerk] MIPS call- en returnfunctie

Als we een functie (een procedure of een subroutine) oproepen, dan zouden we graag na de functie terugkeren naar de plaats waar we in de programmacode gebleven waren. Om dit te kunnen doen moeten we iets vinden om die plaats te onthouden. Er moet een standaard overeengekomen worden waar de terugkeerplaats wordt opgeslagen. MIPS gebruikt register 31 om dit adres in op te slaan. De functies die worden gebruikt om een functie op te roepen en terug te keren naar de oorspronkelijke instructie zijn:

jal - jump and link: Hetzelfde formaat als jump maar als verschil dat jal het terugkeeradres opslaat in register 31, genoemd $ra of return address register.
jr - jump register: In plaats van een vast doeladres te geven zoals bijvoorbeeld een fucntienaam, springt deze instructie naar de locatie die is opgeslagen in register 31.

Als een klein voorbeeldje staat hieronder een functie om een integer af te drukken en een andere die een eindelijn karakter afdrukt.

print_int:

li $v0, 1

syscall

jr $ra

endline:

la $a0, endl #define in .data as "\n"

li $v0, 4