Escola de Engenharia

Universidade Federal de Minas Gerais (UFMG)

ELT123 - Arquitetura e Organização de Computadores

Tópico 4: Arquitetura (Conjunto de Instruções)

Prof. Jhonattan Cordoba Ramirez

Para relembrar!

Categoria Instrução Exemplo O que significa

Adição add $s0, $s1, $s2 $s0 = $s1 + $s2

Aritmética
Subtração sub $s0, $s1, $s2 $s0 = $s1 - $s2

Carregar palavra lw $s0, 10 ( $s1) $s0 = Memória[$s1+10]

Transferência de dados
Armazenar palavra sw $s0, 10 ( $s1) Memória[$s1+10] = $s0
Desvios (Branching)

Condições tecnológicas para tomar decisões

e executar múltiplas tarefas de forma
simultânea

Instruções Instruções
condicionais cíclicas

If/ifelse/else, switch/case,...... For, while, do,…..

Conditional branches and unconditional branches

Desvios (Branching)

• Executar instruções fora da sequencia

• Tipos de desvios:
• Desvio condicional:
• Desviar se for igual (Branch if equal – beq) Condiçã
o
• Desviar se não for igual (Branch if not equal – bne)
• Desvio incondicional: Se Se
condição condição
• Salto (Jump – j) for verdade
Código
não for
verdade
condicionado
• Salto ao registrador (Jump register – jr)
• Salto e ligação (Jump and link – jal)
Desvio condicional

addi $s0, $0, 4 # $s0 = 0 + 4 = 4 addi $s0, $0, 4 # $s0 = 0 + 4 = 4

addi $s1, $0, 1 # $s1 = 0 + 1 = 1 addi $s1, $0, 1 # $s1 = 0 + 1 = 1
sll $s1, $s1, 2 # $s1 = 1 << 2 = 4 sll $s1, $s1, 2 # $s1 = 1 << 2 = 4

beq
beq
$s0, $s1, target # branch
$s0, $s1, target # branch is taken
addi $s1, $s1, 1 # not executed
bne $s0, $s1, target # branch not taken
addi $s1, $s1, 1 # $s1 = 4 + 1 = 5
sub $s1, $s1, $s0 # not executed sub $s1, $s1, $s0 # $s1 = 5 - 4 = 1

target: # label target: # label

add $s1, $s1, $s0 # $s1 = 4 + 4 = 8 add $s1, $s1, $s0 # $s1 = 1 + 4 = 5

Labels indicam a localização da instrução: Não podem ser

palavras reservadas e devem ser seguidos por dois pontos (:)
Desvio incondicional

addi $s0, $0, 4 # $s0 = 0 + 4 = 4 0x00002000 addi $s0, $0, 0x2010 # $s0 = 0x2010
addi $s1, $0, 1 # $s1 = 0 + 1 = 1 0x00002004 jr $s0 # jump to 0x00002010
j target # jump to target 0x00002008 addi $s1, $0, 1 # not executed
addi $s1, $s1, 1 # not executed 0x0000200c sra $s1, $s1, 2 # not executed
sub $s1, $s1, $s0 # not executed 0x00002010 lw $s3, 44($s1) # executado após instrução jr

target: # label
add $s1, $s1, $s0 # $s1 = 1 + 4 = 5 Jump and link???
Construções de código de alto nível

if (i == j)
Código em C f = g + h;
• Instrução if
f = f - i;
• Instrução if/else
• Instrução case bne $s3, $s4, L1
# $s0 = f, $s1 = g, $s2 = h
• Loop while Código Assembly add $s0, $s1, $s2
# $s3 = i, $s4 = j
• Loop for L1: sub $s0, $s0, $s3

O teste codificado em assembly é oposto (i != j) ao código de

alto nível apresentado (i == j)
Construções de código de alto nível

opcode rs rt endereço
beq Reg_1, Reg_2, End
6 bits 5 bits 5 bits 16 bits
• Instrução if
rs e rt são os registradores que serão comparados e o endereço de
• Instrução if/else
16 bits é o desvio.
• Instrução case
• Loop while
• Loop for
Condiçã
o Resposta
falsa
Else
Resposta
verdadeira
Then Código
condicionado
Construções de código de alto nível

if ( x == y ) go to L2; beq $s0, $s1, L2

• Instrução if
• Instrução if/else Condiçã
o Resposta #desvia para L2 se x = y
• Instrução case verdadeir
a
• Loop while a=b-c
Resposta a = b + c; add $s2, $s3, $s4
• Loop for falsa L2
a=b+c

L2 : a = b - c; L2 : sub $s2, $s3, $s4

 Exemplo

endereço Opcode rs rt rd shamt funct

10000 4 16 17 L2

beq $s0, $s1, L2 10004 0 19 20 18 0 32

10008 0 19 20 18 0 34

add $s2, $s3, $s4

endereço opcode rs rt rd shamt funct

10000 000100 10000 10001 0010 0111 0001 1000

L2: sub $s2, $s3, $s4
10004 000000 10011 10100 10010 00000 100000

10008 000000 10011 10100 10010 00000 100010

Construções de código de alto nível

if (i == j)
• Instrução if
Código em C f = g + h;
• Instrução if/else
else
• Instrução case
f = f - i;
• Loop while
• Loop for
bne $s3, $s4, L1
# $s0 = f, $s1 = g, $s2 = h
Código Assembly add $s0, $s1, $s2
# $s3 = i, $s4 = j
J done
L1: sub $s0, $s0, $s3
done
Construções de código de alto nível

opcode rs rt endereço
6 bits 5 bits 5 bits 16 bits
• Instrução if
• Instrução if/else rs e rt são os registradores que serão comparados e o endereço de
• Instrução case 16 bits é o desvio.
• Loop while A instrução BEQ é codificada com o número decimal 04, enquanto
• Loop for BNE é 05.

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

add $s0, $s1, $s2 # f = g + h (salta esta instrução se i <> j)
j Exit # desvia para exit
Else: sub $s0, $s1, $s2 # f = g – h (salta esta instrução se i = j)
Exit:
Construções de código de alto nível

O formato da instrução J é um tipo diferente das instruções R e I. As instruções J

têm apenas dois campos, sendo o OPCODE com 6 bits e o Endereço com 26 bits.
• Instrução if A instrução J é codificada com o número decimal 02.
• Instrução if/else
• Instrução case opcode endereço

• Loop while
6 bits 26 bits

• Loop for Ambas as instruções BEQ e BNE FORÇAM a ida para o bloco de comando ELSE,
sempre devemos nos lembrar disso.
Se usarmos BEQ funcionará? Bom, BEQ forçará a entrada para ELSE se e
somente se i for igual a i. Quando no código em alto nível vai entrar no ELSE?
Entrará no ELSE quando i for diferente de j e não o contrário.
A instrução j, indica o fim da execução desse bloco de instruções e, dessa forma o
processador continua a executar o programa.
 Exemplo
endereço opcode rs rt rd shamt funct

10000 5 19 20 10016

10004 0 17 18 16 0 32

10008 2 10020

bne $s3, $s4, Else 10016 0 17 18 16 0 34

10020 EXIT
add $s0, $s1, $s2
j Exit
endereço opcode rs rt rd shamt funct
Else: sub $s0, $s1, $s2 10000 000100 10011 10100 0010 0111 0010 0000
10004 000000 10001 10010 10000 00000 100000

Exit: 10008 000010 00 0000 0000 0010 0111 0010 0100

10016 000000 10001 10010 10000 00000 100010

10020 EXIT
Desvio incondicional “Branching” (j – jr)

addi $s0, $0, 4 # $s0 = 0 + 4 = 4

0x00002000 addi $s0, $0, 0x2010
addi $s1, $0, 1 # $s1 = 0 + 1 = 1
0x00002004 jr $s0
j target # jump to target
0x00002008 addi $s1, $0, 1
sra $s0, $s1, 2 # not executed
0x0000200C sra $s1, $s1, 2
addi $s1, $s1, 1 # not executed
0x00002010 lw $s3, 44($s1)
sub $s1, $s1, $s0 # not executed

target: # label
add $s1, $s1, $s0 # $s1 = 1 + 4 = 5

Labels indicam a localização da instrução: Não podem ser

palavras reservadas e devem ser seguidos por dois pontos (:)
Construções de código de alto nível

Exercício:

Obtenha alguns números do teclado até ver zero, e calcule a soma das
• Instrução if
entradas.
• Instrução if/else
• Instrução case
syscall para leitura: 5
• Loop while
• Loop for
Construções de código de alto nível

Escolher entre quatro possíveis alternativas:

switch (k)
• Instrução if {
• Instrução if/else case 0: f=i+j; break; /* k=0*/
• Instrução case case 1: f=g+h; break; /* k=1*/
case 2: f=g-h; break; /* k=2*/
• Loop while
case 3: f=i-j; break; /* k=3*/
• Loop for
}

Muito complicado, vamos simplificar!!!

Rescrever como uma sequência de instruções if-else:

If (k==0) f= i + j;
else if (k==1) f= g + h;
else if (k==2) f= g - h;
else if (k==3) f= i - j;
Construções de código de alto nível

// Determinar o valor de x tal que 2x = 128

Código em C int pow = 1;
• Instrução if int x = 0; O teste codificado em assembly é
• Instrução if/else while (pow != 128) { oposto (pow == 128) ao código de alto
• Instrução case pow = pow * 2; nível apresentado (pow != 128)
• Loop while x = pow; }
• Loop for

# $s0 = pow, $s1 = x while: beq $s0, $t0, done

Código addi $s0, $0, 1 # pow = 1 sll $s0, $s0, 1 # pow = pow * 2
Assembly add $s1, $0, $0 #x=0 addi $s1, $0, $s0 # x = pow
addi $t0, $0, 128 # $t0 é igual à j while # jump to
128 para comparação done:
Construções de código de alto nível
For loop (inicialização; condição; operação do Código em C
loop), Inicialização: Executa antes que o loop // Adicione os números de 0 a
• Instrução if comece, Condição: É testado no início de 9
• Instrução if/else cada iteração Operação de loop: Executa no int sum = 0;
• Instrução case final de cada iteração, Declaração: Executa cada int i;
• Loop while vez que a condição é satisfeita. for (i = 0; i == 10; i = i++) {
• Loop for sum = sum + i;}

# $s0 = i, $s1 = sum for: beq $s0, $t0, done # se i == 10, pula para o fim
addi $s1, $0, 0 # sum = 0 add $s1, $s1, $s0 # sum = sum + i
Código
Assembly add $s0, $0, $0 #i=0 addi $s0, $s0, 1 #i=i+1
addi $t0, $0, 10 # $t0 = 10 j for # jump to
done:
Exercícios
if ( x == y) go to L2 if ( a != b)
a = b - c; c = a + b;
b = a + c; a = b - c;
c = b + a; else
L2: b = a + c;
a = a*2 c = b - c;

if ( a == b) if ( a > b) – Para > e para <

c = a + b; c = a + b;
a = b - c; a = b - c;
else else
b = a + c; b = a + c;
c = b - c; c = b - c;