( 1,0 pontos) Encontre a sequência mais curta de instruções MIPS para determinar se existe um carry (estouro) na soma de dois registradores, digamos, os registradores \ \mathrm{t} 3 e$\mathrm{t} 4 . Coloque 0 ou 1 no registrador$$ t2 se o carry for 0 ou 1 , respectivamente.

Passo 1

O enunciado pede: determinar se, ao somar os registradores \$t3 e \$t4, ocorre um carry (estouro no bit de carry inteiro, isto é, carry-out da soma de 32 bits). Colocar no registrador \$t2 o valor 0 se não houve carry, ou 1 se houve carry.\n
Informações relevantes dadas (explicitadas):
  • Temos dois operandos em \$t3 e \$t4 (valores de 32 bits cada).
  • Precisamos escrever 0 ou 1 em \$t2.
  • Podemos usar instruções MIPS usuais (adição sem exceção, comparação unsigned, etc.).
    Não foi dada nenhuma restrição adicional sobre quais registradores temporários podemos usar.

Passo 2

Entendendo o que é “carry” no contexto de soma unsigned de 32 bits. Vou usar notação simples: seja \,a o valor em \$t3 e \,b o valor em \$t4. A soma de 32 bits aritmética sem sinal está em módulo 2^{32}; definimos
s = (a + b) \bmod 2^{32}.
O carry (carry-out) ocorre exatamente quando a + b \ge 2^{32}. Quando isso acontece, o valor armazenado em s é a+b-2^{32}, que é menor que a (porque subtraiu-se 2^{32}). Quando não há carry, s = a+b \ge a. Logo, a condição do carry pode ser detectada testando se
s < a.
Isso é uma propriedade padrão de soma em aritmética modular unsigned: o overflow de carry aparece como “wrap-around” que torna o resultado menor que um dos operandos. Conclusão prática: calcular s e testar se s < a (comparação sem sinal) indica se houve carry.

Passo 3

Traduzindo a ideia para instruções MIPS:
  • Primeiro precisamos do resultado da soma sem causar exceção por overflow de sinal: usamos a instrução \texttt{addu} (adição unsigned ou sem exceção). Guardamos o resultado em um registrador temporário, por exemplo \$t0.
  • Depois comparamos sem sinal \$t0 (o s) com \$t3 (o a) usando \texttt{sltu} (set less than unsigned). A instrução \texttt{sltu} coloca 1 no destino se o primeiro operando for menor que o segundo em ordem unsigned, caso contrário coloca 0. Portanto \texttt{sltu}\\ \$t2,\\ \$t0,\\ \$t3 faz \$t2 \leftarrow (s < a), exatamente o bit de carry que queremos.

Passo 4

Escrevendo explicitamente as instruções e explicando cada uma:
  1. \texttt{addu\\ }\$t0,\\ \$t3,\\ \$t4\n
    • Calcula s = a + b (sem exceção), guarda em \$t0. Aqui \$t0 é temporário.
  2. \texttt{sltu\\ }\$t2,\\ \$t0,\\ \$t3\n
    • Faz a comparação unsigned s < a. Se verdadeiro, \$t2 recebe 1 (houve carry); se falso, recebe 0.
Exemplo numérico para fixar: suponha a=0xFFFFFFF0 ( 4294967280) e b=0x20 ( 32). Então a+b = 4294967312 \ge 2^{32}, o resultado em 32 bits é s = 16 ( 0x10), e s < a é verdadeiro → \$t2=1. Para a=5, b=3: s=8 e s < a é falso → \$t2=0.

Passo 5

Por que essa sequência é minimal (mais curta) razoável:
  • Precisamos tanto de s quanto de um teste comparativo unsigned. Não existe em MIPS uma única instrução que calcule s e também escreva em um registrador 1 ou 0 baseado no carry-out. A instrução \texttt{add} gera exceção em overflow de sinal e não fornece o bit de carry para registrador; \texttt{addu} dá o resultado but não o carry; \texttt{sltu} faz comparação unsigned, mas precisa de dois registradores para comparar. Portanto precisamos ao menos de uma instrução para obter s e outra para testar s<a. Duas instruções é, portanto, o mínimo prático.

Resposta

addu \$t0,\\ \$t3,\\ \$t4\n
sltu \$t2,\\ \$t0,\\ \$t3

Exercícios relacionados