MIPS ALU OpCodes são usados no
funct Campo das instruções do tipo R para especificar a operação precisa realizada pela unidade lógica aritmética (ALU). O campo `opcode` na instrução é sempre` 0x00` para instruções do tipo R, e o campo `funct` distingue entre diferentes operações. Aqui está um colapso dos códigos comuns do MIPS ALU Funct e suas operações correspondentes, agrupadas por tipo de clareza:
Operações aritméticas: *
`add` (adição): * `funct =0x20` (100000 em binário)
* Adiciona dois registros e armazena o resultado em um registro de destino. O transbordamento * faz * causar uma exceção.
*
`addu` (adição não assinado): * `funct =0x21` (100001 em binário)
* Adiciona dois registros e armazena o resultado em um registro de destino. O excesso é * ignorado * (sem exceção). Use isso para aritmética modular ou quando você souber o transbordamento é impossível/aceitável.
*
`sub` (subtração): * `funct =0x22` (100010 em binário)
* Subtraia um registro de outro e armazena o resultado em um registro de destino. O transbordamento * faz * causar uma exceção.
*
`subu` (subtração não assinada): * `funct =0x23` (100011 em binário)
* Subtraia um registro de outro e armazena o resultado em um registro de destino. O excesso é * ignorado * (sem exceção).
*
`mult` (multiplicação): * `funct =0x18` (011000 em binário)
* Multiplica dois registros. O resultado de 64 bits é armazenado nos registros `hi` e` lo`.
*
`multu` (multiplicação não assinada): * `funct =0x19` (011001 em binário)
* Multiplica dois registros como valores não assinados. O resultado de 64 bits é armazenado nos registros `hi` e` lo`.
*
`div` (divisão): * `funct =0x1a` (011010 em binário)
* Divide um registro por outro. O quociente é armazenado no registro `lo 'e o restante é armazenado no registro` hi'.
*
`divu` (divisão não assinada): * `funct =0x1b` (011011 em binário)
* Divide um registro por outro como valores não assinados. O quociente é armazenado no registro `lo 'e o restante é armazenado no registro` hi'.
Operações lógicas: *
`e` (bitwise e): * `funct =0x24` (100100 em binário)
* Executa um bit e operação em dois registros e armazena o resultado em um registro de destino.
*
`ou` (bitwise ou): * `funct =0x25` (100101 em binário)
* Executa um bit a operação em dois registros e armazena o resultado em um registro de destino.
*
`xor` (bitwise xor): * `funct =0x26` (100110 em binário)
* Executa uma operação XOR (exclusiva ou) bit -netwise em dois registros e armazena o resultado em um registro de destino.
*
`nor` (bitwise nem): * `funct =0x27` (100111 em binário)
* Executa um desempenho bit bit (não (não ou) em dois registros e armazena o resultado em um registro de destino.
*
`sll` (Shift Left Logical): * `funct =0x00` (000000 em binário)
* Descobra um registro deixado por um número especificado de bits (especificado no campo `shamt` da instrução do tipo R). Os zeros são deslocados da direita.
*
`srl` (mudança à direita lógica): * `funct =0x02` (000010 em binário)
* Descobra um registro diretamente por um número especificado de bits (especificado no campo `shamt` da instrução do tipo R). Os zeros são deslocados da esquerda.
*
`SRA` (aritmética direita de mudança): * `funct =0x03` (000011 em binário)
* Descobra um registro diretamente por um número especificado de bits (especificado no campo `shamt` da instrução do tipo R). O bit de sinal (bit mais significativo) é replicado e deslocado da esquerda, preservando o sinal do número.
Configurar-se-sim-than (operações relacionais): *
`slt` (definido menos que): * `funct =0x2a` (101010 em binário)
* Define o registro de destino para 1 se o primeiro registro for menor que o segundo registro e 0 caso contrário. Trata os registros como números inteiros assinados.
*
`sltu` (definido menos que não assinado): * `funct =0x2b` (101011 em binário)
* Define o registro de destino para 1 se o primeiro registro for menor que o segundo registro e 0 caso contrário. Trata os registros como números inteiros não assinados.
Outras operações da ALU (importantes, mas não diretamente as operações no mesmo sentido que acima): *
`mfhi` (mova de hi): * `funct =0x10` (010000 em binário)
* Move o valor do registro `hi` (que armazena os 32 bits superiores de um resultado de multiplicação ou o restante de uma divisão) para um registro de uso geral.
*
`mflo` (mova -se de lo): * `funct =0x12` (010010 em binário)
* Move o valor do registro `lo` (que armazena os 32 bits inferiores de um resultado de multiplicação ou o quociente de uma divisão) para um registro de uso geral.
*
`mthi` (mova -se para oi): * `funct =0x11` (010001 em binário)
* Move o valor de um registro de uso geral para o registro HI.
*
`mtlo` (mova para lo): * `funct =0x13` (010011 em binário)
* Move o valor de um registro de uso geral para o registro de LO.
*
`jr` (registro de salto): * `funct =0x08` (001000 em binário)
* Salta para o endereço armazenado no registro especificado. É assim que a função retorna geralmente é implementada. Embora envolva o registro de endereço, o ALU provavelmente é usado para calcular o endereço de destino.
*
`syscall` (chamada do sistema): * `funct =0x0c` (001100 em binário)
* Invoca o sistema operacional para executar um serviço de sistema. O serviço solicitado é identificado por um código no registro `$ v0` (` $ 2`).
Considerações importantes: * Formato do tipo R: Todas essas instruções são do tipo R, o que significa que eles usam o seguinte formato:
`opcode | rs | rt | rd | shamt | funct`
Onde:
* `opcode`:sempre 0x00 para instruções do tipo R.
* `rs`:registro de origem 1
* `rt`:registro de origem 2
* `rd`:registro de destino
* `shamt`:quantidade de mudança (usada apenas por instruções de turno)
* `funct`:o código da função que especifica a operação específica.
*
não assinado vs. assinado: O sufixo `u` (por exemplo,` adu`, `subu`,` multu`, `divu`,` sltu`) indica que os operandos são tratados como números inteiros não assinados. Isso afeta como o transbordamento é tratado e como as comparações são realizadas.
*
oi e lo registros: Os registros `hi` e` lo` são registros de uso especial usado para armazenar os resultados das operações de multiplicação e divisão.
*
Conjunto de instruções Variações: Diferentes implementações do MIPS podem incluir instruções adicionais ou ligeiramente modificadas. A lista acima abrange as operações mais comuns e amplamente suportadas.
Esse detalhamento abrangente deve fornecer uma sólida compreensão dos códigos MIPs ALU (códigos FUNCT) e das operações que eles executam. Ao escrever a montagem do MIPS, sempre consulte a documentação específica para a arquitetura MIPS que você está direcionando para garantir a precisão.
