MIPS ALU -opcoder används i
funct Fält för R-typinstruktioner för att specificera den exakta operationen som utförs av den aritmetiska logikenheten (ALU). Fältet "Opcode" i instruktionen är alltid "0x00" för R-typ-instruktioner och fältet "Funct" skiljer mellan olika operationer. Här är en uppdelning av de gemensamma MIPS ALU -funct -koderna och deras motsvarande operationer, grupperade efter typ för tydlighet:
aritmetiska operationer:
* `add` (tillägg):
* `Funct =0x20` (100000 i binär)
* Lägger till två register och lagrar resultatet i ett destinationsregister. Överflöde * orsakar ett undantag.
* `addu` (tillägg osignerad):
* `funct =0x21` (100001 i binär)
* Lägger till två register och lagrar resultatet i ett destinationsregister. Överflödet är * ignoreras * (inget undantag). Använd detta för modulär aritmetik, eller när du vet att överflödet är omöjligt/acceptabelt.
* `sub` (subtraktion):
* `funct =0x22` (100010 i binär)
* Subtraherar ett register från en annan och lagrar resultatet i ett destinationsregister. Överflöde * orsakar ett undantag.
* `subu` (subtraktion osignerad):
* `funct =0x23` (100011 i binär)
* Subtraherar ett register från en annan och lagrar resultatet i ett destinationsregister. Överflödet är * ignoreras * (inget undantag).
* `mult` (multiplikation):
* `funct =0x18` (011000 i binär)
* Multiplicerar två register. 64-bitarsresultatet lagras i registerna "Hi" och "lo".
* `multu` (multiplikation osignerad):
* `funct =0x19` (011001 i binär)
* Multiplicerar två register som osignerade värden. 64-bitarsresultatet lagras i registerna "Hi" och "lo".
* `div` (division):
* `funct =0x1a` (011010 i binär)
* Delar ett register av ett annat. Kvoten lagras i "lo" -registret och resten lagras i "HI" -registret.
* `divu` (division osignerad):
* `funct =0x1b` (011011 i binär)
* Dela upp ett register med ett annat som osignerade värden. Kvoten lagras i "lo" -registret och resten lagras i "HI" -registret.
Logiska operationer:
* `och` (bitwise och):
* `funct =0x24` (100100 i binär)
* Utför lite och operation i två register och lagrar resultatet i ett destinationsregister.
* `eller` (bitvis eller):
* `Funct =0x25` (100101 i binär)
* Utför en bitvis eller operation i två register och lagrar resultatet i ett destinationsregister.
* `xor` (bitvis xor):
* `Funct =0x26` (100110 i binär)
* Utför en bitvis XOR (exklusiv eller) operation i två register och lagrar resultatet i ett destinationsregister.
* `inte heller (bitvis eller):
* `Funct =0x27 '(100111 i binär)
* Utför en bitvis eller (inte eller) operation i två register och lagrar resultatet i ett destinationsregister.
* `sll` (skift vänster logisk):
* `funct =0x00` (000000 i binär)
* Skiftar ett register som lämnats av ett specifikt antal bitar (specificerat i fältet "Shamt" i R-typen av R-typ). Nollor flyttas in från höger.
* `srl` (skift höger logisk):
* `funct =0x02` (000010 i binär)
* Skiftar ett register direkt med ett specifikt antal bitar (specificerat i fältet "Shamt" i R-typen av R-typ). Nollor flyttas in från vänster.
* `sra` (skift till höger aritmetik):
* `funct =0x03` (000011 i binär)
* Skiftar ett register direkt med ett specifikt antal bitar (specificerat i fältet "Shamt" i R-typen av R-typ). Skyltbiten (mest betydande bit) replikeras och skiftas in från vänster och bevarar tecknet på numret.
set-on-less-than (relationella operationer):
* `sLt` (ställ in mindre än):
* `funct =0x2a` (101010 i binär)
* Ställer in destinationsregistret till 1 om det första registret är mindre än det andra registret och 0 annars. Behandlar register som signerade heltal.
* `Sltu` (ställ in mindre än osignerad):
* `funct =0x2b` (101011 i binär)
* Ställer in destinationsregistret till 1 om det första registret är mindre än det andra registret och 0 annars. Behandlar register som osignerade heltal.
Andra ALU -operationer (viktiga, men inte direkt ALU -operationer i samma mening som ovan):
* `mfhi` (flytta från HI):
* `funct =0x10` (010000 i binär)
* Flyttar värdet från "HI" -registret (som lagrar de övre 32 bitarna av ett multiplikationsresultat eller resten av en division) till ett allmänt register.
* `mflo` (flytta från lo):
* `funct =0x12` (010010 i binär)
* Flyttar värdet från "Lo" -registret (som lagrar de lägre 32 bitarna i ett multiplikationsresultat eller kvoten på en division) till ett allmänt register.
* `mthi` (flytta till HI):
* `funct =0x11` (010001 i binär)
* Flyttar värdet från ett allmänt register i HI -registeret.
* `mtlo` (flytta till lo):
* `funct =0x13` (010011 i binär)
* Flyttar värdet från ett allmänt register i LO -registret.
* `jr` (Jump Register):
* `funct =0x08` (001000 i binär)
* Hoppar till adressen lagrad i det angivna registret. Så här implementeras funktionsavkastningen vanligtvis. Även om det involverar adressregistret används ALU troligen för att beräkna måladressen.
* `syscall` (systemsamtal):
* `funct =0x0c` (001100 i binär)
* Åberopar operativsystemet för att utföra en systemtjänst. Den begärda tjänsten identifieras med en kod i register `$ v0` (` $ 2 ').
Viktiga överväganden:
* r-typformat: Alla dessa instruktioner är R-typ, vilket innebär att de använder följande format:
`Opcode | rs | rt | rd | shamt | funct`
Där:
* `OpCode`:Alltid 0x00 för instruktioner av R-typ.
* `RS`:Källregister 1
* `rt`:källregister 2
* `RD`:Destination Register
* `Shamt`:Skiftbelopp (används endast av skiftinstruktioner)
* `Funct`:Funktionskoden som anger den specifika operationen.
* osignerad kontra signerad: `U` -suffixet (t.ex.` addu`, `subu`,` multu`, `divu`,` sLtu`) indikerar att operanden behandlas som osignerade heltal. Detta påverkar hur överflödet hanteras och hur jämförelser utförs.
* hej och lo register: Registren "Hi" och "Lo" är specialregister som används för att lagra resultaten av multiplikation och uppdelningsoperationer.
* Instruktionsuppsättning Variationer: Olika MIPS -implementeringar kan innehålla ytterligare eller något modifierade instruktioner. Ovanstående lista täcker de vanligaste och allmänt stödda operationerna.
Denna omfattande uppdelning bör ge dig en solid förståelse av MIPS ALU -opcoder (Funct -koder) och de operationer de utför. När du skriver MIPS -montering, hänvisar alltid till den specifika dokumentationen för MIPS -arkitekturen du riktar dig till för att säkerställa noggrannhet.
