Você está na página 1de 9

IFMG - Campus Formiga

Ministério da Educação - Governo Federal


R. São Luiz Gonzaga, s/n, Bairro São Luiz / MG - CEP 35.577-010
Tel.: (37) 3322-8432 - https://www.formiga.ifmg.edu.br
DISCIPLINA: Arquitetura e Organização de PROFESSOR: Roger Santos MÉDIA: 3
Computadores
ATIVIDADE: Exercícios de Assembly Ferreira
DATA: VALOR: 5 pts.
MIPS (GABARITO) 17/06/2021 TURMA:
pts. NOT
ALUNO(A): MAT.: A:
CC2020-3
1. Considerando os registradores para cada variável definida, escreva a tradução de cada pseudo código a seguir
em Assembly MIPS:

a) a = b - c REGISTRADORE
sub $s0, $s1, $s2 S:
b) b = a + c a = $s0
add $s1, $s0, $s2 b = $s1
c) d = (a + b - c) c = $s2
add $t0, $s0, $s1 d = $s3
sub $s3, $t0, $s2 e = $s4
d) f = (a + b) - d
add $t0, $s0, $s1
sub $s5, $t0, $s3
e) c = a - (b + d)
add $t0, $s1, $s3
sub $s2, $s0, $t0
f) e = (a - (b - c))
sub $t0, $s1, $s2
sub $s4, $s0, $t0
g) e = (a - (b - c) + f)
sub $t0, $s1, $s2
sub $t0, $s0, $t0
add $s4, $t0, $s5
h) f = e - (a - b) + (b - c)
sub $t0, $s0, $s1
sub $t1, $s1, $s2
sub $t0, $s3, $t0
add $s4, $t0, $t1

2. Usando os registradores definidos, converta as seguintes instruções em C para Assembly MIPS:

a) a = b[15] - c; REGISTRADORE
lw $t0, 60($s1) S:
sub $s0, $t0, $s2 a = $s0
b) b = a[5] + c[3]; b = $s1
lw $t0, 20($s0)
lw $t1, 12($s2)
add $s2, $t0, $t1
c) c = b - a[21];
lw $t0, 84($s0)
sub $s2, $s1, $t0
3. Usando os registradores e endereços base definidos, converta as seguintes instruções em C para Assembly
MIPS:

a) a[10] = f - g;
REGISTRADORE ENDEREÇOS BASE:a
sub $t0, $s0, $s1
S: = $s4
sw $t0, 40($s4)
f = $s0 b = $s5
b) b[245] = h + g;
g = $s1 c = $s6
add $t0, $s2, $s1
h = $s2
sw $t0, 980($s5)
i = $s3
c) c[0] = i - f;
sub $t0, $s3, $s0
sw $t0, 0($s6)

4. Usando os registradores e endereços base definidos, traduza as seguintes instruções em C para Assembly MIPS.
Tente usar o mínimo de registradores temporários na solução da tradução.

a) a[34] = b[3] + g - h; REGISTRADORE ENDEREÇOS BASE:a


lw $t0, 12($s4) S: = $s3
add $t0, $t0, $s0 g = $s0 b = $s4
sub $t0, $t0, $s1 h = $s1 c = $s5
sw $t0, 136($s3) i = $s2 d = $s6
b) a[45] = i -g + d[67];
lw $t0, 268($s6)
add $t0, $t0, $s0
sub $t0, $s2, $t0
sw $t0, 180($s3)
c) a[79] = i - c[18] + h;
lw $t0, 72($s5)
add $t0, $t0, $s1
sub $t0, $s2, $t0
sw $t0, 316($s3)
d) a[82] = b[2] - c[4];
lw $t0, 8($s4)
lw $t1, 16($s5)
sub $t0, $t0, $t1
sw $t0, 328($s3)

5. Considerando os registradores definidos, converta as seguintes instruções em C para Assembly MIPS:

a) soma = 0; REGISTRADORES:
for (int i = 0; i < 3; i++) { i = $s0
soma = soma + 1; n = $s1
} soma = $t1
a = $s6 = [0, 1, 2, 3, 4,
# implementado no MARS
.data
.text
li $s0, 0 # i = 0 ($s0 é i)
li $s1, 3 #n=3
li $t1, 0 # soma = 0

LOOP:
# condição de saída do FOR
slt $t0, $s0, $s1 # $t0 = 1 se i < 3, $t0 = 0 se i >= 3
beq $t0, $zero, EXIT # se $s0 >= $s3 (i >= n) vá para EXIT
# iterações
addi $t1, $t1, 1 # soma = soma + 1

# incremento do contador
addi $s0, $s0, 1 # i++
j LOOP # volta para o LOOP
EXIT:

li $v0, 1 # se prepare para imprimir um inteiro na tela


add $a0, $zero, $t1 # calcula o que deve ser mostrado na tela
syscall

b) while(a[i] < 5) {
printf(“O valor de a[i] é: %d”)
i += 1;
}
# implementado no MARS
.data
a: .word 0, 1, 2, 3, 4, 5
texto: .asciiz "O valor de a[i] é: "

.text
li $s0, 0 # i = $s0 = 0
li $s1, 5 # n = $s1 = 5
la $s6, a # carregando o endereço do array a no registrador $s6

# criando o LOOP
LOOP:
sll $t1, $s0, 2 # $t1 = 4 * i (4 * $s0)
add $t1, $t1, $s6 # a[i] = (4*i + $s6)
lw $t0, 0($t1) # $t0 = a[i]
beq $t0, $s1, EXIT # vá para EXIT se a[i] == 5

li $v0, 4 # se prepare para exibir uma string (4)


la $a0, texto # $a0 = texto a imprimir
syscall # imprime na tela o texto

li $v0, 1 # se prepare para exibir um inteiro na tela (1)


add $a0, $zero, $t0 # $a0 = a[i]
syscall # imprime na tela o inteiro a[i]

li $v0, 11 # impressão de um caractere


addi $a0, $0, 0xA # impressão de nova linha
syscall
addi $s0, $s0, 1 # $s3 = $s3 + 1 (ou i = i + 1)
j LOOP # volta para o LOOP
EXIT:

6. Considerando os registradores e endereços base definidos, resolva as questões 6.1 a 6.3.

REGISTRADOR ENDEREÇOS BASE:a =


a) f = f + A[2]; ES: $s6 (word de 4 bytes)
b) B[8] = A[i] + A[j]; f = $s0g = $s1 b = $s7 (word de 4
h = $s2 bytes)
i = $s3j = $s4

6.1. Para as instruções C da questão 6, qual é o código


assembly do MIPS correspondente?

a) lw $s0, 4($s7)
sub $s0, $s0, $s1
add $s0, $s0, $s2

b) add $t0, $s7, $s1


lw $t0, 0($t0)
add $t0, $t0, $s6
lw $s0, 4($t0)

6.2. Para as instruções C da questão 6, quantas instruções assembly do MIPS são necessárias a fim de executá-
las?

a) 3
b) 4

6.3. Para as instruções C da questão 6, quantos registradores são necessários a fim de executá-las em código
assembly MIPS?

a) 4
b) 5

7. Os problemas a seguir lidam com a tradução de MIPS para C. Considerando os registradores e endereços base
definidos, resolva as questões 7.1 a 7.3.
REGISTRADOR ENDEREÇOS BASE:A =
a) sub $s0, $s0, $s1 ES: $s6 (word de 4 bytes)
sub $s0, $s0, $s3 f = $s0g = $s1 B = $s7 (word de 4
add $s0, $s0, $s1 h = $s2 bytes)
b) addi $t0, $s6, 4 i = $s3j = $s4
add $t1, $s6, $zero
sw $t1, 0($t0)
lw $t0, 0($t0)
add $s0, $t1, $t0

7.1. Para as instruções assembly MIPS da questão 7, qual é o código C correspondente?


a) Resposta do Hennessy e Patterson ⇒ f = 2i + h (nem tem o h no código!!!!);
Minha resposta ⇒ f = f - i; afinal, (f-g) e (f+g) se anulam e continua sendo f
b) Resposta do Hennessy e Patterson ⇒ f = A[g - 3] (o g nem aparece no código!!!);
Minha resposta ⇒ f = A[0] + A[1];

7.2. Para o assembly MIPS da questão 7, considere que os registradores $s0, $s1, $s2, $s3 contêm os valores
0x0000000a, 0x00000014, 0x0000001e e 0x00000028, respectivamente. Além disso, suponha que o registrador
$s6 contenha o valor 0x00000100, e que a memória contém os seguintes valores:

Endereço Valor
0x00000100 0x00000064
0x00000104 0x000000c8
0x00000106 0x0000012c

PERGUNTA: Qual o valor de $s0 ao final do código assembly?

a) Resposta do Hennessy e Patterson ⇒ $s0 = 110!!!?¿


Minha resposta ⇒ $s0 = -30 (em decimal)
b) Resposta do Hennessy e Patterson ⇒ $s0 = 300!!!?¿
Minha resposta ⇒ $s0 = 200 (em decimal)

7.3. Em cada instrução MIPS da questão 7, mostre o valor dos campos op, rs e rt. Para as instruções tipo I,
mostre o valor do campo imediato, e com as instruções tipo R, mostre o valor do campo rd.

c) sub $s0, $s0, $s1


sub $s0, $s0, $s3
add $s0, $s0, $s1
d) addi $t0, $s6, 4
add $t1, $s6, $zero
sw $t1, 0($t0)
lw $t0, 0($t0)
add $s0, $t1, $t0
a)
inst. tipo opcode rd rs rt imediato /
func
sub $s0, $s0, $s1 R 0 16 16 17 22
sub $s0, $s0, $s3 R 0 16 16 19 22
add $s0, $s0, $s1 R 0 16 16 17 20

b)
inst. tipo opcode rd rs rt imediato /
func
addi $t0, $s6, 4 I 8 8 22 0x0004
add $t1, $s6, $zero R 0 9 22 0
sw $t1, 0($t0) I 2b 8 9 end. $t0
lw $t0, 0($t0) I 23 8 8 end. $t0
add $s0, $t1, $t0 R 0 16 9 8
8. ROTEIRO PRÁTICO DE SIMULAÇÃO MIPS

Antes de resolver as questões restantes, faça um minicurso de assembly MIPS 32 de Amell Peralta,
disponibilizado gratuitamente no YouTube (shorturl.at/jrL26). São vídeos pequenos e bem auto-explicativos que
ensinam do básico ao intermediário sobre o assunto estudado. Apesar de ser um conteúdo em inglês, o
YouTube nos permite habilitar legendas automáticas pelo áudio do vídeo e também traduzi-las em tempo real.

Observação: não há a necessidade de ver todo o curso para resolver os problemas abaixo, creio que os primeiros
20 a 25 vídeos já darão uma base legal para começarmos a entender na prática funcionamento do assembly
MIPS através do simulador MARS (versão 4.5 disponível para download em: shorturl.at/otxF5). O MARS é um
aplicativo Java que não precisa ser instalado, apenas executado. Se assemelha muito a uma IDE de
programação C ou Java. Sintam-se livres para explorar suas opções de menu e aprender durante os exercícios.
Gostaria de salientar as seguintes opções de menu:

Settings > Addresses displayed in hexadecimal


Settings > Values displayed in hexadecimal
Help > Help (extremamente útil, principalmente a partes de syscalls)

Dica: caso queira treinar e melhor entender os conceitos, sugiro realizar os exercícios anteriores no MARS, de
forma a debugar e acompanhar o passo-a-passo da execução.

8.1. Uso básico do MARS:

Inicialize o MARS baixado do link acima. Observe que o MARS necessita do Java SE instalado no computador
para sua correta execução. Observe ainda as abas de edição / execução (Edit / Execute) e de mensagens /
entradas - saídas (Mars Messages / Run I/O). Por fim, verifique o painel de registradores (registers), de
registradores de ponto flutuante (Coproc 1) e de registradores de interrupção (Coproc 0). Note que todos os 32
registradores MIPS são nomeados e numerados, em adição a três registradores de controle extras: pc (Program
Counter), hi e lo, os quais detalharemos mais adiante.

a) Observando tal estado geral, informe quais registradores possuem um valor não zerado neste ponto.
$gp (global pointer), $sp (stack pointer), pc (program counter)
b) Explique o que o valor atual do pc indica.
O PC sempre contém o endereço da próxima instrução a se executar em um programa. Uma vez que
neste momento o programa ainda não está executando, o endereço inicial 0x00400000 é o endereço da
primeira instrução da aplicação.
c) Execute o código a seguir no MARS, observe seu comportamento e responda às seguintes questões:
.data
numero1: .word 5 # reserve o espaço de um inteiro na memória e coloque o valor 5 nele
numero2: .word 10 # reserve o espaço de um inteiro na memória e coloque o valor 10 nele

.text
lw $t0, numero1($zero) # carregue a word numero1 em offset 0 para $t0
lw $t1, numero2($zero) # carregue a word numero2 em offset 0 para $t1

add $t2, $t0, $t1 # some $t0 com $t1 e armazene em $t2

li $v0, 1 # se prepare para imprimir um inteiro na tela


add $a0, $zero, $t2 # some 0 com $t2 e armazene em $a0
syscall # execute a chamada de sistema
i) O que esse algoritmo realiza?
Ele simplesmente soma dois números inteiros e exibe o resultado na tela
ii) O que discerne as diretivas .data e .text?
.data = espaço de declaração de variáveis e alocação de espaço em memória primária (RAM)
.text = texto do código-fonte do algoritmo
iii) O que a notação 0x precedente aos números de oito dígitos significa (exemplo: 0x0040000)?
0x indica que o número está representado em notação hexadecimal.
iv) Após executar o algoritmo, temos acesso à aba Execute, a qual nos permite controles e
visualização de variadas informações (painéis Text Segment e Data Segment). Defina cada uma
delas a seguir:

● Bkpt: indica se um breakpoint está definido no endereço indicado


● Address: local da memória que aloca a instrução específica
● Code: código de máquina (binário) da instrução
● Basic: versão da instrução em código assembly (de montagem), usando a ISA MIPS
● Source: código-fonte original, que pode diferir caso sejam usadas pseudo-instruções

v) Qual o endereço de início do programa carregado? 0x00400000


vi) O segmento de dados (Data Segment) contém o código da seção .data do programa (variáveis e
constantes definidas). Qual é o endereço de início do segmento de dados? 0x10010000

d) Verifique as possibilidades de velocidade de execução, por exemplo, 1 instrução por segundo. Verifique
ainda as opções de debug e execução passo-a-passo. Tais opções são excepcionais para o auxílio ao
processo de ensino-aprendizagem deste conteúdo.

Execute o código a seguir no MARS e observe seu comportamento/código:


.data
msg1: .asciiz "Qual seu nome? "
msg2: .asciiz "Qual sua idade? "
nome: .space 10
tamanho: .word 10
idade: .word 50

.text
li $v0, 4
la $a0, msg1
syscall

li $v0, 8
la $a0, nome
la $a1, tamanho
syscall

li $v0, 4
la $a0, msg2
syscall

li $v0, 5
la $a0, idade
syscall

Modifique o código acima de forma que ele apresente o seguinte resultado no console. Solicito o favor
de comentar o código devidamente:
Insira seu nome completo: Roger Santos Ferreira
Qual sua idade atual? 36

Olá, Roger Santos Ferreira


Daqui 5 anos você terá 41 anos!

.data
msg1: .asciiz "Insira seu nome completo: "
msg2: .asciiz "Qual sua idade? "
msg3: .asciiz "Olá, "
msg4: .asciiz "Daqui 5 anos você terá "
msg5: .asciiz " anos!"
nome: .space 50
tamanho: .word 50
idade: .word 40

.text
# exibe a msg1
li $v0, 4
la $a0, msg1
syscall

# le o nome completo
li $v0, 8
la $a0, nome
la $a1, tamanho
syscall

# exibe a msg2
li $v0, 4
la $a0, msg2
syscall

# le a idade
li $v0, 5
syscall

# soma idade + 5 e guarda na memória


addi $t0, $v0, 5
sw $t0, idade

# imprime linha em branco


li $v0, 11
addi $a0, $0, 0xA
syscall

# exibe a msg3
li $v0, 4
la $a0, msg3
syscall

# exibe o nome
li $v0, 4
la $a0, nome
syscall

# exibe a msg4
li $v0, 4
la $a0, msg4
syscall

# exibe a idade + 5 anos


li $v0, 1
lw $a0, idade
syscall

# exibe a msg5
li $v0, 4
la $a0, msg5
syscall
REFERÊNCIAS:
● PATTERSON, David A.; HENNESSY, John L. Organização e Projeto de Computadores: A interface Hardware/Software
● HENDRIX COLLEGE. MIPS Reference Card. Disponível em: <http://www.cburch.com/cs/330/reading/mips-ref.pdf>.
● STALLINGS, William. Arquitetura e organização de computadores.
● TANENBAUM, Andrew S. Organização Estruturada de Computadores.

Você também pode gostar