Operazioni aritmetiche:
* `add` (aggiunta):
* `funct =0x20` (100000 in binario)
* Aggiunge due registri e memorizza il risultato in un registro di destinazione. Overflow * fa * un'eccezione.
* `addu` (aggiunta non firmata):
* `funct =0x21` (100001 in binario)
* Aggiunge due registri e memorizza il risultato in un registro di destinazione. L'overflow è * ignorato * (nessuna eccezione). Usalo per l'aritmetica modulare o quando sai che lo overflow è impossibile/accettabile.
* `sub` (sottrazione):
* `funct =0x22` (100010 in binario)
* Sottrae un registro da un altro e memorizza il risultato in un registro di destinazione. Overflow * fa * un'eccezione.
* `subu` (sottrazione non firmata):
* `funct =0x23` (100011 in binario)
* Sottrae un registro da un altro e memorizza il risultato in un registro di destinazione. L'overflow è * ignorato * (nessuna eccezione).
* `Multiplication):
* `funct =0x18` (011000 in binario)
* Moltiplica due registri. Il risultato a 64 bit è conservato nei registri `hi` e` lo`.
* `Multu` (moltiplicazione non firmata):
* `funct =0x19` (011001 in binario)
* Moltiplica due registri come valori non firmati. Il risultato a 64 bit è conservato nei registri `hi` e` lo`.
* `Div` (Divisione):
* `funct =0x1a` (011010 in binario)
* Divide un registro per un altro. Il quoziente è archiviato nel registro `lo` e il resto è archiviato nel registro` hi '.
* `Divu` (divisione non firmata):
* `funct =0x1b` (011011 in binario)
* Divide un registro per un altro come valori non firmati. Il quoziente è archiviato nel registro `lo` e il resto è archiviato nel registro` hi '.
Operazioni logiche:
* `e` (bitwise e):
* `funct =0x24` (100100 in binario)
* Esegui un bitwise e operazioni su due registri e memorizza il risultato in un registro di destinazione.
* `o` (bitwise o):
* `funct =0x25` (100101 in binario)
* Esegui un bitwise o un'operazione su due registri e memorizza il risultato in un registro di destinazione.
* `xor` (bitwise xor):
* `funct =0x26` (100110 in binario)
* Esegue un'operazione XOR (esclusiva o) bitwise su due registri e memorizza il risultato in un registro di destinazione.
* `nor` (bitwise né):
* `funct =0x27` (100111 in binario)
* Esegue un'operazione bitwise né (non o) su due registri e memorizza il risultato in un registro di destinazione.
* `sll` (spostamento logico a sinistra):
* `funct =0x00` (000000 in binario)
* Sposta un registro lasciato da un numero specificato di bit (specificato nel campo `Shamt` dell'istruzione di tipo R). Gli zero vengono spostati da destra.
* `srl` (spostamento a destra logico):
* `funct =0x02` (000010 in binario)
* Sposta un registro a destra di un numero specificato di bit (specificato nel campo `Shamt` dell'istruzione di tipo R). Gli zero vengono spostati da sinistra.
* `sra` (sposta a destra aritmetica):
* `funct =0x03` (000011 in binario)
* Sposta un registro a destra di un numero specificato di bit (specificato nel campo `Shamt` dell'istruzione di tipo R). Il bit di segno (bit più significativo) viene replicato e spostato da sinistra, preservando il segno del numero.
set-on-let-than (Operazioni relazionali):
* `slt` (imposta meno di):
* `funct =0x2a` (101010 in binario)
* Imposta il registro di destinazione su 1 se il primo registro è inferiore al secondo registro e 0 altrimenti. Tratta i registri come numeri interi firmati.
* `sltu` (impostato meno che non firmato):
* `funct =0x2b` (101011 in binario)
* Imposta il registro di destinazione su 1 se il primo registro è inferiore al secondo registro e 0 altrimenti. Tratta i registri come numeri interi non firmati.
Altre operazioni di Alu (importanti, ma non direttamente operazioni di Alu nello stesso senso di quanto sopra):
* `mfhi` (spostati da hi):
* `funct =0x10` (010000 in binario)
* Sposta il valore dal registro `hi` (che memorizza i 32 bit superiori di un risultato di moltiplicazione o il resto di una divisione) a un registro per scopi generali.
* `mflo` (spostati da lo):
* `funct =0x12` (010010 in binario)
* Sposta il valore dal registro `lo` (che memorizza i 32 bit inferiori di un risultato di moltiplicazione o il quoziente di una divisione) a un registro per uso generale.
* `mthi` (sposta su hi):
* `funct =0x11` (010001 in binario)
* Sposta il valore da un registro di scopi generali nel registro HI.
* `mtlo` (sposta su lo):
* `funct =0x13` (010011 in binario)
* Sposta il valore da un registro per scopi generali nel registro LO.
* `jr` (salto registro):
* `funct =0x08` (001000 in binario)
* Salta all'indirizzo memorizzato nel registro specificato. Ecco come vengono in genere implementati i rendimenti delle funzioni. Sebbene coinvolga il registro degli indirizzi, l'ALU viene probabilmente utilizzata per calcolare l'indirizzo target.
* `syscall` (chiamata di sistema):
* `funct =0x0c` (001100 in binario)
* Invoca il sistema operativo per eseguire un servizio di sistema. Il servizio richiesto è identificato da un codice nel registro `$ v0` (` $ 2`).
Considerazioni importanti:
* Formato di tipo R: Tutte queste istruzioni sono di tipo R, il che significa che usano il seguente formato:
`opcode | rs | RT | Rd | Shamt | funct`
Dove:
* `opcode`:sempre 0x00 per istruzioni di tipo R.
* `rs`:Registro di origine 1
* `rt`:Registro di origine 2
* `rd`:Registro di destinazione
* `shamt`:importo del cambio (usato solo dalle istruzioni a turni)
* `funct`:il codice funzione che specifica l'operazione particolare.
* non firmato vs. firmato: Il suffisso `u` (ad es.,` Addu`, `subu`,` multu`, `divu`,` sltu`) indica che gli operandi sono trattati come numeri interi non firmati. Ciò influisce su come viene gestito l'overflow e come vengono eseguiti i confronti.
* hi e lo registri: I registri `hi` e` lo` sono registri per scopi speciali utilizzati per archiviare i risultati delle operazioni di moltiplicazione e di divisione.
* Variazioni di set di istruzioni: Diverse implementazioni MIPS potrebbero includere istruzioni aggiuntive o leggermente modificate. L'elenco di cui sopra copre le operazioni più comuni e ampiamente supportate.
Questa rottura completa dovrebbe darti una solida comprensione degli opcodi MIPS ALU (codici funct) e delle operazioni che eseguono. Quando si scrivono l'assemblaggio MIPS, fare sempre riferimento alla documentazione specifica per l'architettura MIPS che stai prendendo di mira per garantire l'accuratezza.
Programmazione © www.354353.com