Dentre as alternativas, quais programas em MIPS traduzem o código em C abaixo?
int min(int a, int b) {
    if (a < b)
        return a;
    else
        return b;
}
a) min:
    blt \(a0,\)a1, then
    add \(v0,\)0, $a0
    j min_exit
    then:
    add \(v0,\)0, $a1
    min_exit:
    jr $ra
b) min:
    add \(v0,\)0, $a0
    blt \(a0,\)a1, min_xt
    add \(v0,\)0, $a1
    min_xt:
    jr $ra
c) min:
    blt \(a0,\)a1, then
    add \(v0,\)0, $a1
    j min_exit
    then:
    add \(v0,\)0, $a0
    min_exit:
    jr $ra
d) min:
    bge \(a0,\)a1, then
    add \(v0,\)0, $a1
    j min_exit
    then:
    add \(v0,\)0, $a0
    min_exit:
    jr $ra

Passo 1

O enunciado pede: dentre as quatro alternativas (a), (b), (c) e (d), quais programas em MIPS traduzem corretamente a função C abaixo:
\text{int min(int a, int b) \{}
\qquad \text{if (a < b)}
\qquad\qquad \text{return a;}
\qquad \text{else}
\qquad\qquad \text{return b;}
\text{\}}
Informações relevantes dadas (pressuposições padrão de MIPS que usaremos):
  • Os parâmetros chegam em \$a0 (que representa a) e em \$a1 (que representa b).
  • O valor de retorno deve estar em \$v0.
  • O retorno para o chamador é feito com \$ra via instrução \text{jr }\$ra.
  • Precisamos que a função retorne o menor entre \$a0 e \$a1: se \$a0 < \$a1 então retornar \$a0, caso contrário retornar \$a1.
  • Vou analisar cada alternativa instrução por instrução e testar os dois casos relevantes: \$a0 < \$a1 e \$a0 \ge \$a1.

Passo 2

Breve explicação das instruções MIPS que aparecerão nas alternativas (para você entender o que cada linha faz):
  • \text{add }\$v0,\$0,\$a0: copia o valor de \$a0 para \$v0 (porque \$0 é o registrador com valor 0). Em palavras: \$v0 \leftarrow \$a0.
  • \text{add }\$v0,\$0,\$a1: copia \$a1 para \$v0. Em palavras: \$v0 \leftarrow \$a1.
  • \text{blt }\$a0,\$a1, \text{label}: se \$a0 < \$a1 então desvia para label, caso contrário continua na próxima instrução.
  • \text{bge }\$a0,\$a1, \text{label}: se \$a0 \ge \$a1 então desvia para label, caso contrário continua.
  • \text{j label}: salto incondicional para label.
  • \text{jr }\$ra: retorna ao chamador (usa \$ra como endereço de retorno).
    Essas semânticas são fundamentais para rastrear o fluxo de controle e decidir se um trecho implementa corretamente o if/else.

Passo 3

Análise da alternativa (a):
Código dado (reproduzido aqui com os registradores entre ... para ficar claro):
  • \text{blt }\(\$a0, \$a1,\ then)
  • \text{add }\(\$v0, \$0, \$a0)
  • \text{j min\_exit}
  • \text{then:}
  • \text{add }\(\$v0, \$0, \$a1)
  • \text{min\_exit:}
  • \text{jr }\(\$ra)
Vamos seguir os dois casos:
  • Caso \$a0 < \$a1: a instrução \text{blt } é verdadeira, portanto pula para o rótulo \text{then}. No rótulo \text{then} a instrução é \text{add }\(\$v0,$0,$a1)) — isto faz \$v0 \leftarrow \$a1. Resultado: retorna \$a1.
    • Mas o esperado quando \$a0 < \$a1 é retornar \$a0. Então isso está invertido.
  • Caso \$a0 \ge \$a1: a \text{blt} falha, então executa a linha seguinte \text{add }\(\$v0,$0,$a0)) que faz \$v0 \leftarrow \$a0, e depois salta para \text{min\_exit} e retorna. Resultado: retorna \$a0.
    • No caso \$a0 \ge \$a1 o esperado é retornar \$a1. Aqui também está invertido.
Conclusão da (a): o código devolve o valor oposto ao desejado (quando a<b retorna b, quando a\ge b retorna a). Portanto (a) está INCORRETA.

Passo 4

Análise da alternativa (b):
Código:
  • \text{add }\(\$v0, \$0, \$a0)
  • \text{blt }\(\$a0, \$a1,\ min_xt)
  • \text{add }\(\$v0, \$0, \$a1)
  • \text{min\_xt:}
  • \text{jr }\(\$ra)
Interpretando passo a passo:
  • A primeira instrução já faz \$v0 \leftarrow \$a0. Ou seja, por padrão o retorno é preparado como a.
  • Em seguida vem \text{blt }\(\$a0, \$a1,\ min_xt). Se \$a0 < \$a1 (caso em que queremos retornar a), a instrução \text{blt} é verdadeira e o fluxo vai para \text{min\_xt}, que é imediatamente seguido por \text{jr }\$ra: assim o valor já carregado em \$v0 (que é \$a0) é retornado.
  • Se \$a0 \ge \$a1, a \text{blt} falha e a execução continua na próxima instrução: \text{add }\(\$v0,$0,$a1)), que sobrescreve \$v0 com \$a1. Depois vem \text{min\_xt} e \text{jr }\$ra: retorna \$a1.
Testes rápidos:
  • Se \$a0 = 1,\\ \$a1 = 2 (ou seja 1<2): antes do branch \$v0=1; branch verdadeiro pula para \text{min\_xt}; retorna 1 — correto.
  • Se \$a0 = 5,\\ \$a1 = 3 (ou seja 5\ge 3): \text{blt} falso; executa \$v0\leftarrow3; retorna 3 — correto.
Conclusão da (b): comportamento correto, implementa exatamente o if: se a<b retorna a, senão retorna b. Portanto (b) está CORRETA.

Passo 5

Análise da alternativa (c):
Código:
  • \text{blt }\(\$a0, \$a1,\ then)
  • \text{add }\(\$v0, \$0, \$a1)
  • \text{j min\_exit}
  • \text{then:}
  • \text{add }\(\$v0, \$0, \$a0)
  • \text{min\_exit:}
  • \text{jr }\(\$ra)
Seguimento dos casos:
  • Se \$a0 < \$a1: \text{blt} é verdadeira, então pula para \text{then}, onde se executa \$v0 \leftarrow \$a0; depois chega em \text{min\_exit} e faz \text{jr }\$ra: retorna \$a0 — correto.
  • Se \$a0 \ge \$a1: \text{blt} falha, então executa a instrução seguinte \$v0 \leftarrow \$a1, depois salta para \text{min\_exit} e retorna \$a1 — correto.
Observação: (c) usa a forma “se então faz A; senão faz B” com um salto incondicional para pular o ramo contrário — padrão clássico e correto.
Conclusão da (c): implementa corretamente a função min, portanto (c) está CORRETA.

Passo 6

Análise da alternativa (d):
Código:
  • \text{bge }\(\$a0, \$a1,\ then)
  • \text{add }\(\$v0, \$0, \$a1)
  • \text{j min\_exit}
  • \text{then:}
  • \text{add }\(\$v0, \$0, \$a0)
  • \text{min\_exit:}
  • \text{jr }\(\$ra)
Vamos ver:
  • Se \$a0 \ge \$a1: a instrução \text{bge} é verdadeira, então pula para \text{then} e executa \$v0 \leftarrow \$a0, retornando a. Mas o correto quando a \ge b é retornar b. Aqui está errado.
  • Se \$a0 < \$a1: \text{bge} falha, então executa a próxima instrução \$v0 \leftarrow \$a1 e retorna b. Quando a<b o correto é retornar a, mas aqui retorna b. Também errado.
Portanto (d) também está invertido (semelhante a (a) mas usando bge).
Conclusão da (d): INCORRETA.

Passo 7

Resumo do raciocínio (motivação prática para a prova):
  • O comportamento desejado é: se \$a0 < \$a1 então \$v0 \leftarrow \$a0, senão \$v0 \leftarrow \$a1.
  • Ao analisar cada trecho, basta seguir o fluxo das instruções condicionais ( \text{blt}, \text{bge}) e ver que valor fica em \$v0 antes do \text{jr }\$ra.
  • Alternativas (b) e (c) deixam \$v0 com o menor dos dois registros nos dois casos; (a) e (d) fazem o contrário.

Resposta

(b) e (c)

Exercícios relacionados