Conjunto de instruções mips - instruções de desvio

Conjunto de Instruções MIPSENGENHARIA DE COMPUTAÇÃO

UNIVERSIDADE SAGRADO CORAÇÃO

PROF.ª MA. ELAINE CECÍLIA GATTO

INSTRUÇÕES DE DESVIO

A utilidade de um computador reside na possibilidade de se usar uma sequencia de instruções repetidamente, sendo que o número de iterações depende fundamentalmente do resultado dos cálculos realizados pelo próprio programa.

Quando a iteração se completar, uma outra sequencia de instruções será executada, de modo que precisamos, na maioria dos casos, especificar dois conjuntos paralelos de instruções precedidos de uma instrução que vai determinar qual das duas sequencias será executada.


Esta escolha poderá depender do sinal de um número, com o zero sendo reconhecimento como positivo, para os propósitos da máquina.

Consequentemente, devemos introduzir uma instrução – a instrução de transferência condicional – que irá, dependendo do sinal de um dado número, fazer com que uma das duas sequências seja executada.

BURKS, GOLDSTINE E VON NEUMANN - 1947


A diferença entre um COMPUTADOR e uma simples CALCULADORA eletrônica é a capacidade do computador de escolher entre diversos caminhos de execução.

Com base em dados de entrada e em valores criados durante a execução do programa, diferentes instruões poderão vir a ser executadas.


A tomada de decisão geralmente é representada nas linguagens de programação pelo comando IF, às vezes combinado com o GO TO e com LABELS.

A linguagem de montagem MIPS inclui duas instruções de desvio, similares a um IF e a um GO TO combinados. A primeira dessas instruções é:

BEQ REGISTRADOR1, REGISTRADOR2, L1


Esta instrução, quando executada, forçará um desvio par ao comando com o LABEL L1, se o valor no REGISTRADOR1 for igual ao valor no REGISTRADOR2.

O mnemônico BEQ refere-se à DESVIE SE IGUAL – BRANCH IF EQUAL.

BEQ REGISTRADOR1, REGISTRADOR2, L1


A segunda instrução é:

BNE REGISTRADOR1, REGISTRADOR2, L1

Significa que a próxima instrução a ser executada é aquela que estiver armazenada no endereço de L1 da memória, se o valor no REGISTRADOR1 for diferente do valor no REGISTRADOR2.

O mnemonico BNE refere-se a DESVIE SE NÃO IGUAL – BRANCH IF NOT EQUAL. As duas instruções são tradicionalmente chamadas de INSTRUÇÕES DE DESVIO CONDICIONAL

COMPILAÇÃO DE UM COMANDO IF EM UMA INSTRUÇÃO DE DESVIO CONDICIONAL

No segmento de código a seguir, escrito em linguagem C:

if(i==j) go to L1;

f = g + h;

L1: f = f – i;

F = $s0, g = $s1, h = $s2, i = #s3, j = $s4


SOLUÇÃO:

beq $s3, $s4, L1 # Desvia para L1 se I for igual a Jadd $s0, $s1, $s2 # f = g + h executa esta instrução SE i = j

L1: sub $s0, $s0, $s3 # f = f – i sempre será executado

O primeiro comando em C compara duas variáveis e desvia para a operação de subtração se elas forem iguais. L1 é o desvio. Essa instrução C é mapeada diretamente para MIPS


SOLUÇÃO:

beq $s3, $s4, L1 # Desvia para L1 se I for igual a J

add $s0, $s1, $s2 # f = g + h executa esta instrução SE i = jL1: sub $s0, $s0, $s3 # f = f – i sempre será executado

O comando seguinte na linguagem C realiza uma única operação. O código gerado para ele possui simplesmente uma única instrução


SOLUÇÃO:

beq $s3, $s4, L1 # Desvia para L1 se I for igual a J

add $s0, $s1, $s2 # f = g + h executa esta instrução SE i = j

L1: sub $s0, $s0, $s3 # f = f – i sempre será executado

O último comando em C também é compilado em uma única instrução. PROBLEMA: como especificar o seu endereço de maneira tal que o

desvio condicional possa saltar a instrução de soma escrita acima


As instruções estão armazenadas na memória das máquinas com programa armazenado.

A cada instrução está implicitamente associado um endereço na memória correspondente à palavra que ela estiver ocupando.

A última instrução do código gerado para o MIPS simplesmente INCORPORA o LABEL L1, referenciado pela instrução BEQ

Portanto, o LABEL L1 corresponde ao endereço onde a instrução SUB está armazenada.


Observe que o montador desobriga tanto o compilador quanto o programador na linguagem de montagem da tarefa estafantes e tediosa de calcular os endereços para os desvios, a exemplo do que já acontecia com os cálculos dos endereços dos dados nas instruções de load e store

INTERFACE HARDWARE / SOFTWARE

Com frequencia os compiladores são obrigados a criar desvios e labels que não aparecem na programação de alto nível.

Evitar o desgaste de ter que escrever labels explicitos e desvios é um dos benefícios de se programar em uma linguagem de alto nível, e o principal motivo para justificar a rapidez de se programar neste nível

COMPILAÇÃO DO COMANDO IF-THEN-ELSE EM DESVIOS CONDICIONAIS

Obtenha o código MIPS gerado para o seguinte comando em C:

if (i == j)

f = g + h;

else f = g – h;

Considere: f = $s0, g = $s1, h = $s2, i = #s3, j = $s4


SOLUÇÃO

bne $s3, $s4, Else #desvia para Else se i<>j

add $s0, $s1, $s2 #salta essa instrução se i<>j

j Exit #desvia para EXIT

Else: sub $s0, $s1, $s2 #salta essa instrução se i=j

Exit:


SOLUÇÃO: A primeira expressão do comando C compara dois valores, em busca

da igualdade, de modo que fica muito claro que precisaremos da instrução BEQ mais uma vez

O código será mais eficiente se fizermos o teste em busca da condição oposta, para que possamos desviar sobre o código que executa a parte subsequente, correspondente ao THEN


SOLUÇÃO: O comando em C realiza uma única operação, e o código gerado para ele

tem simplesmente uma única instrução

É necessário ir para o fim do comando IF. Para isso é necessário introduzir outro comando de desvio, chamado de DESVIO INCONCIDICONAL.

Essa instrução faz com que a máquina SEMPRE execute o desvio. Para fazer distinção entre o DESVIO CONDICIONAL e o DESVIO INCONDICIONAL, o MIPS chama este último tipo de instrução de JUMP (desvio) abreviado como J

LOOPS

Os comandos de desvio são importantes tanto para se escolher entre duas alternativas – caso dos comandos IF – quanto para controlar iterações de uma determinada computação – caso dos LOOPS

As mesmas instruções da linguagem de montagem são usadas na construção de ambas as estruturas

COMPILAÇÃO DE UM LOOP CONTENDO UM ARRAY COM ÍNDICE VARIÁVEL

Seja o LOOP programado em linguagem em C abaixo:

Loop: g = g + A[i];

i = i + j;

if(i != h) go to Loop;

G = $s1, h = $s2, i = $s3, j = $s4, A = $s5. Qual é o código, em linguagem de montagem do MIPS, que corresponde a este loop escrito em C?


SOLUÇÃO:

Loop: add $t1, $s3, $s3 # T1 = 2 * 1

add $t1, $t1, $t1 # T 1 = 4 * 1

add $t1, $t1, $s5 # T1 = A[i]

lw $t0, 0($t1) # T0 = A[i]

add $s1, $s1, $t0 # g = g + A[i]

add $s3, $s3, $s4 # i = i + j

bne $s3, $s2, Loop # desvia para LOOP se i <> j


SOLUÇÃO:

O primeiro passo é carregar o valor de A[i] em um registrador temporário;

É necessário apenas adicionar o label LOOP à primeira instrução de modo a podermos desviar para esta instrução ao final do loop

Considerando que o corpo do loop modifica o valor de i, é necessário multiplicá-lo por 4 cada vez que entramos no loop


As sequencias de instruções terminadas em um desvio são tão fundamenais para a compilação que receberam definição própria:

Um BLOCO BÁSICO é uma sequencia de instruções SEM DESVIO, exceto possivelmente no final, e sem labels-alvo de desvios, exceto talvez no inicio

Uma das primeiras tarefas do processo de compilação é dividir o programa em blocos básicos

COMPILAÇÃO DE UM LOOP WHILE

É responsabilidade do compilador traduzir os loops tradicionais para a linguagem do MIPS. Programadores não escrevem mais loops usando GO TO. Segue o código WHILE em linguagem C.

While(save[i] == k)

I = i + j

i = $s3, j = $s4, k = $s5, save = $s6. Qual é o código em linguagem de montagem do MIPS correspondente?


SOLUÇÃO:

Loop: add $t1, $s3, $s3 # t1 = 2 * i

add $t1, $t1, $t1 # t1 = 4 * i

add $t1, $t1, $s6 # t1 = save[i]

lw $t0, 0($t1) # t0 = save[i]

bne $t0, $s5, Exit # desvia para Exit se save[i]<>k

add $s3, $s3, $s4 # i = i + j

j Loop # i = i + j

Exit:


SOLUÇÃO: O primeiro passo é carregar o valor save[i] em um registrador temporário O código começa similar ao do exemplo anterior A próxima instrução é responsável pelo testo do loop, saindo dele se

save[i] <> k: A próximo instruão soma j com i A instrução final do loop desvia de volta para o teste do WHILE no início do

LOOP. Para marcar o fim do LOOP, simplesmente adicionamos o label EXIT após

esta instrução


Os testes de igualdade ou desigualdade talvez sejam os mais populares de todos os testes de condição, mas às vezes é preciso verificar se o valor de determinada variável é menor que o valor de outra

Um loop FOR pode precisar realizar um teste para verificar se o valor corrente do índice é menor que zero.

Tais comparações, no código do MIPS, são realizadas com uma instrução que compara os valores de dois registradores e atribui o valor 1 a um terceiro, se o valor do primeiro registrador for menor que o do segundo


Caso contrário, atribui-se o valor zero a esse terceiro registrador.

Essa instrução do MIPS é chamada de instrução SET ON LESS THAN ou SLT

slt $t0, $s3, $s4

Significa que o registrador $t0 assume o valor 1 caso o conteúdo do registrador $s3 seja menor que o valor armazenado em $s4, caso contrário, o registrador $t0 recebe o valor zero


Os compiladores que geram código para o MIPS usam as instruções SLT, BNE e BEQ, e o valor fixo $zero, disponível no registrador READ ONLY denominado $ZERO, para criar todas as demais condições relativas. O registrador $zero é mapeado no registrador zero. Igual Não-igual Menor que Menor ou igual a Maior que Maior ou igual a

COMPILAÇÃO DE TESTE LESS THAN

Qual o código MIPS para testar se uma variável A, correspondente ao registrador $s0, é menor que outra variável B, no registrador $s1, e desviar para o LABEL Less se a condição for verdaeira?

SOLUÇÃO:

slt $t0, $s0, $s1 # T0 = 1 SE $s0 < $s1 (se a < b)

bne $t0,$zero, Less # desvia para LESS se $t0<>0

# (se a < b)


SOLUÇÃO:

O primeiro passo é usar a instrução SET ON LESS associada a um registrador temporário;

Após a execução dessa instrução, o registrador $t0 recebe o valor 1 se A for menor que B.

Portanto, uma instrução de desvio para verificar se o conteúdo de $t0 é nulo terá o mesmo efeito de um desvio se A é menor que B.


SOLUÇÃO:

Considerando que o registrador $zero contém sempre o valor zero armazenado, este último teste é realizado a partir de uma instrução BNE para comparar $t0 com $zero.

O par de instruções, SLT e BNE, implementa um J desvio se menor que


Seguindo o conselho de VON NEUMANN sobre a simplicidade do equipamento, a arquitetura do MIPS não inclui em seu conjunto de instruções a instrução BRANCH IF LESS THAN, porque sua implementação é muito complicada

Para tê-la no conjunto de instruções, seria necessário aumentar o ciclo de clock ou implementá-la gastando muitos ciclos de clock, o que aumentaria a quantidade média de ciclos gastos por instrução.

Em vez de uma instrução lenta, é melhor duas instruções rápidas

COMANDO CASE / SWITCH

COMPILAÇÃO DE UM COMANDO SWITCH A PARTIR DE UMA TABELA DE ENDEREÇOS DE DESVIO

Education

Conjunto de instruções mips - instruções de desvio