Operaciones aritméticas:
* `add` (adición):
* `funct =0x20` (100000 en binario)
* Agrega dos registros y almacena el resultado en un registro de destino. El desbordamiento * causa * una excepción.
* `addu` (adicional sin firmar):
* `funct =0x21` (100001 en binario)
* Agrega dos registros y almacena el resultado en un registro de destino. El desbordamiento es * ignorado * (sin excepción). Use esto para la aritmética modular, o cuando sabe que el desbordamiento es imposible/aceptable.
* `sub` (resta):
* `funct =0x22` (100010 en binario)
* Resta un registro de otro y almacena el resultado en un registro de destino. El desbordamiento * causa * una excepción.
* `Subu` (subtracción sin firmar):
* `funct =0x23` (100011 en binario)
* Resta un registro de otro y almacena el resultado en un registro de destino. El desbordamiento es * ignorado * (sin excepción).
* `mult` (multiplicación):
* `funct =0x18` (011000 en binario)
* Multiplica dos registros. El resultado de 64 bits se almacena en los registros `Hi` y` Lo`.
* `multu` (multiplicación sin firmar):
* `funct =0x19` (011001 en binario)
* Multiplica dos registros como valores sin firmar. El resultado de 64 bits se almacena en los registros `Hi` y` Lo`.
* `div` (división):
* `funct =0x1a` (011010 en binario)
* Divide un registro de otro. El cociente se almacena en el registro 'lo' y el resto se almacena en el registro 'HI`.
* `divu` (división sin firmar):
* `funct =0x1b` (011011 en binario)
* Divide un registro por otro como valores sin firmar. El cociente se almacena en el registro 'lo' y el resto se almacena en el registro 'HI`.
Operaciones lógicas:
* `y` (bitwise y):
* `funct =0x24` (100100 en binario)
* Realiza un bitwise y operación en dos registros y almacena el resultado en un registro de destino.
* `o` (bitwise o):
* `funct =0x25` (100101 en binario)
* Realiza un bitwise u operación en dos registros y almacena el resultado en un registro de destino.
* `xor` (bitwise xor):
* `funct =0x26` (100110 en binario)
* Realiza una operación XOR (exclusiva o) bitwise en dos registros y almacena el resultado en un registro de destino.
* `nor` (bitwise nor):
* `funct =0x27` (100111 en binario)
* Realiza un bitwise ni (no o) operación en dos registros y almacena el resultado en un registro de destino.
* `SLL` (Shift Left Logical):
* `funct =0x00` (000000 en binario)
* Cambia un registro dejado por un número especificado de bits (especificado en el campo 'Shamt` de la instrucción de tipo R). Los ceros se cambian de la derecha.
* `srl` (desplazamiento derecho lógico):
* `funct =0x02` (000010 en binario)
* Cambia un derecho de registro mediante un número especificado de bits (especificado en el campo 'Shamt` de la instrucción de tipo R). Los ceros se cambian desde la izquierda.
* `sra` (aritmética derecha de cambio):
* `funct =0x03` (000011 en binario)
* Cambia un derecho de registro mediante un número especificado de bits (especificado en el campo 'Shamt` de la instrucción de tipo R). El bit de signo (bit más significativo) se replica y cambia desde la izquierda, preservando el signo del número.
set-on-no-que (operaciones relacionales):
* `slt` (establecido menos que):
* `funct =0x2a` (101010 en binario)
* Establece el registro de destino en 1 si el primer registro es menor que el segundo registro, y 0 de lo contrario. Trata a los registros como enteros firmados.
* `sltu` (establecido menos que sin firmar):
* `funct =0x2b` (101011 en binario)
* Establece el registro de destino en 1 si el primer registro es menor que el segundo registro, y 0 de lo contrario. Trata a los registros como enteros sin firmar.
Otras operaciones de ALU (importantes, pero no directamente operaciones de ALU en el mismo sentido que el anterior):
* `mfhi` (muévase de HI):
* `funct =0x10` (010000 en binario)
* Mueve el valor del registro `Hi` (que almacena los 32 bits superiores de un resultado de multiplicación o el resto de una división) a un registro de propósito general.
* `mflo` (moverse de lo):
* `funct =0x12` (010010 en binario)
* Mueve el valor del registro `lo` (que almacena los 32 bits inferiores de un resultado de multiplicación o el cociente de una división) a un registro de propósito general.
* `mthi` (mudarse a HI):
* `funct =0x11` (010001 en binario)
* Mueve el valor de un registro de propósito general al registro HI.
* `mtlo` (mudarse a lo):
* `funct =0x13` (010011 en binario)
* Mueve el valor de un registro de propósito general al registro de LO.
* `jr` (registro de salto):
* `funct =0x08` (001000 en binario)
* Salta a la dirección almacenada en el registro especificado. Así es como los retornos de funciones se implementan típicamente. Aunque implica el registro de direcciones, la ALU probablemente se usa para calcular la dirección de destino.
* `syscall` (llamada del sistema):
* `funct =0x0c` (001100 en binario)
* Invoca el sistema operativo para realizar un servicio del sistema. El servicio solicitado se identifica mediante un código en el registro `$ V0` (` $ 2`).
Consideraciones importantes:
* formato de tipo R: Todas estas instrucciones son de tipo R, lo que significa que usan el siguiente formato:
`Opcode | RS | RT | RD | Shamt | funcionamiento
Dónde:
* `Opcode`:siempre 0x00 para instrucciones de tipo R.
* `RS`:Registro de origen 1
* `rt`:registro de origen 2
* `RD`:Registro de destino
* `Shamt`:Cantidad de cambio (usado solo por instrucciones de turno)
* `Funct`:el código de función que especifica la operación particular.
* Unsigned vs. firmado: El sufijo `u` (por ejemplo,` addu`, `subu`,` multu`, `divu`,` sltu`) indica que los operandos se tratan como enteros sin firmar. Esto afecta cómo se maneja el desbordamiento y cómo se realizan las comparaciones.
* hola y lo registrados: Los registros `Hi` y` Lo` son registros de uso especial utilizados para almacenar los resultados de las operaciones de multiplicación y división.
* Variaciones establecidas de instrucciones: Las diferentes implementaciones de MIPS pueden incluir instrucciones adicionales o ligeramente modificadas. La lista anterior cubre las operaciones más comunes y ampliamente compatibles.
Este desglose integral debería darle una comprensión sólida de los códigos de operación MIPS ALU (códigos de función) y las operaciones que realizan. Al escribir el ensamblaje de MIPS, siempre consulte la documentación específica para la arquitectura MIPS que se dirige para garantizar la precisión.