Rekenkundige bewerkingen:

* `toevoegen` (toevoeging):

* `funct =0x20` (100.000 in binair getal)

* Voegt twee registers toe en slaat het resultaat op in een bestemmingsregister. Overflow *veroorzaakt* een uitzondering.

* `addu` (Toevoeging niet ondertekend):

* `funct =0x21` (100001 in binair getal)

* Voegt twee registers toe en slaat het resultaat op in een bestemmingsregister. Overloop wordt *genegeerd* (geen uitzondering). Gebruik dit voor modulaire rekenkunde, of als u weet dat overflow onmogelijk/acceptabel is.

* `sub` (Aftrekken):

* `funct =0x22` (100010 in binair getal)

* Trekt het ene register van het andere af en slaat het resultaat op in een bestemmingsregister. Overflow *veroorzaakt* een uitzondering.

* `subu` (Aftrekken zonder teken):

* `funct =0x23` (100011 in binair getal)

* Trekt het ene register van het andere af en slaat het resultaat op in een bestemmingsregister. Overloop wordt *genegeerd* (geen uitzondering).

* `mult` (vermenigvuldigen):

* `funct =0x18` (011000 in binair getal)

* Vermenigvuldigt twee registers. Het 64-bits resultaat wordt opgeslagen in de registers 'hi' en 'lo'.

* `multu` (Vermenigvuldiging zonder teken):

* `funct =0x19` (011001 in binair getal)

* Vermenigvuldigt twee registers als waarden zonder teken. Het 64-bits resultaat wordt opgeslagen in de registers 'hi' en 'lo'.

* `div` (Divisie):

* `function =0x1A` (011010 in binair getal)

* Verdeelt het ene register door het andere. Het quotiënt wordt opgeslagen in het 'lo'-register en de rest wordt opgeslagen in het 'hi'-register.

* `divu` (Divisie niet ondertekend):

* `funct =0x1B` (011011 in binair getal)

* Verdeelt het ene register door het andere als waarden zonder teken. Het quotiënt wordt opgeslagen in het 'lo'-register en de rest wordt opgeslagen in het 'hi'-register.

Logische bewerkingen:

* `en` (Bitgewijs AND):

* `funct =0x24` (100100 in binair getal)

* Voert een bitsgewijze AND-bewerking uit op twee registers en slaat het resultaat op in een bestemmingsregister.

* `of` (Bitgewijs OF):

* `funct =0x25` (100101 in binair getal)

* Voert een bitsgewijze OR-bewerking uit op twee registers en slaat het resultaat op in een bestemmingsregister.

* `xor` (Bitgewijze XOR):

* `funct =0x26` (100110 in binair getal)

* Voert een bitsgewijze XOR-bewerking (exclusieve OR) uit op twee registers en slaat het resultaat op in een bestemmingsregister.

* `nor` (Bitgewijze NOR):

* `funct =0x27` (100111 in binair getal)

* Voert een bitsgewijze NOR (NOT OR)-bewerking uit op twee registers en slaat het resultaat op in een bestemmingsregister.

* `sll` (Logisch naar links verschuiven):

* `funct =0x00` (000000 in binair getal)

* Verschuift een register naar links met een gespecificeerd aantal bits (gespecificeerd in het `shamt`-veld van de R-type instructie). Nullen worden vanaf rechts verschoven.

* `srl` (Shift Right Logical):

* `funct =0x02` (000010 in binair getal)

* Verschuift een register naar rechts met een gespecificeerd aantal bits (gespecificeerd in het `shamt`-veld van de R-type instructie). Nullen worden van links naar binnen geschoven.

* `sra` (Shift Right Rekenkunde):

* `funct =0x03` (000011 in binair getal)

* Verschuift een register naar rechts met een gespecificeerd aantal bits (gespecificeerd in het `shamt`-veld van de R-type instructie). Het tekenbit (meest significante bit) wordt gerepliceerd en van links naar binnen geschoven, waarbij het teken van het getal behouden blijft.

Less-Than instellen (relationele bewerkingen):

* `slt` (kleiner instellen dan):

* `function =0x2A` (101010 in binair getal)

* Stelt het bestemmingsregister in op 1 als het eerste register kleiner is dan het tweede register, en anders op 0. Behandelt de registers als gehele getallen met teken.

* `sltu` (kleiner dan niet-ondertekend instellen):

* `funct =0x2B` (101011 in binair getal)

* Stelt het bestemmingsregister in op 1 als het eerste register kleiner is dan het tweede register, en anders op 0. Behandelt de registers als gehele getallen zonder teken.

Andere ALU-bewerkingen (belangrijk, maar niet rechtstreeks ALU-bewerkingen in dezelfde zin als hierboven):

* `mfhi` (Verplaats van HI):

* `funct =0x10` (010000 in binair getal)

* Verplaatst de waarde van het 'hi'-register (waar de bovenste 32 bits van een vermenigvuldigingsresultaat of de rest van een deling worden opgeslagen) naar een register voor algemene doeleinden.

* `mflo` (Verplaats van LO):

* `funct =0x12` (010010 in binair getal)

* Verplaatst de waarde van het 'lo'-register (waar de onderste 32 bits van een vermenigvuldigingsresultaat of het quotiënt van een deling worden opgeslagen) naar een register voor algemene doeleinden.

* `mthi` (Verplaats naar HI):

* `funct =0x11` (010001 in binair getal)

* Verplaatst de waarde van een register voor algemene doeleinden naar het HI-register.

* `mtlo` (Verplaats naar LO):

* `funct =0x13` (010011 in binair getal)

* Verplaatst de waarde van een register voor algemene doeleinden naar het LO-register.

* `jr` (Springregistratie):

* `funct =0x08` (001000 in binair getal)

* Springt naar het adres dat is opgeslagen in het opgegeven register. Dit is hoe functieretouren doorgaans worden geïmplementeerd. Hoewel het om het adresregister gaat, wordt de ALU waarschijnlijk gebruikt om het doeladres te berekenen.

* `syscall` (Systeemoproep):

* `funct =0x0C` (001100 in binair getal)

* Roept het besturingssysteem op om een ​​systeemservice uit te voeren. De gevraagde dienst wordt geïdentificeerd door een code in register `$v0` ("$2").

Belangrijke overwegingen:

* R-type formaat: Al deze instructies zijn van het R-type, wat betekent dat ze het volgende formaat gebruiken:

`opcode | rs | rt | rd | schijn | functie`

Waar:

* `opcode`:Altijd 0x00 voor R-type instructies.

* `rs`:Bronregister 1

* `rt`:Bronregister 2

* `rd`:Bestemmingsregister

* `shamt`:Hoeveelheid ploeg (alleen gebruikt door ploeginstructies)

* `funct`:De functiecode die de specifieke bewerking specificeert.

* Niet-ondertekend versus ondertekend: Het achtervoegsel `u` (bijvoorbeeld `addu`, `subu`, `multu`, `divu`, `sltu`) geeft aan dat de operanden worden behandeld als gehele getallen zonder teken. Dit heeft invloed op de manier waarop overflow wordt afgehandeld en hoe vergelijkingen worden uitgevoerd.

* HI- en LO-registers: De registers 'hi' en 'lo' zijn registers voor speciale doeleinden die worden gebruikt om de resultaten van vermenigvuldigings- en delingsbewerkingen op te slaan.

* Instructiesetvariaties: Verschillende MIPS-implementaties kunnen aanvullende of enigszins gewijzigde instructies bevatten. De bovenstaande lijst omvat de meest voorkomende en breed ondersteunde bewerkingen.

Deze uitgebreide uitsplitsing zou u een goed inzicht moeten geven in de MIPS ALU-opcodes (functiecodes) en de bewerkingen die ze uitvoeren. Raadpleeg bij het schrijven van MIPS-assemblage altijd de specifieke documentatie voor de MIPS-architectuur waarop u zich richt, om nauwkeurigheid te garanderen.