Código em Linguagem de Máquina LT34E – Arquitetura e Organização de Computadores

Código em Linguagem de Máquina1

Gabriel de A. Leite
Universidade Tecnológica Federal do Paraná – UTFPR
COELE – Coordenação do Curso de Engenharia Eletrônica
Campo Mourão, Paraná, Brasil
gabriell.arruda20@hotmail.com

Resumo }
}
}
O trabalho tem o propósito de nos fazer enxergar
como uma máquina se comporta recebendo instruções int main(){
de alto nível. Mostrando o processo desde o dado int dados[5];
inicial até o dado processado pela mesma. for(int i = 0; i < 5; i++){

printf("Digite o numero %d: ",

i+1);
Introdução scanf("%d", &dados[i]);

O projeto proposto de trata da tradução do código de }

uma linguagem de programação de alto nível para o parImpar(dados);
}
Assembly do MIPS, com a codificação no formato de
Imagem 1: Código fonte do programa em C
instruções. Para isso foi escolhido o código em C que
recebe cinco valores e os armazena em um vetor,
verificando e dando a devolutiva de cada número sobre
quais são pares e quais são impares. Após a formulação Código em Assembly
em C foi realizado a tradução para o ASSEMBLY e .data
com a codificação do mesmo pronta traduzida para dados:
formato de instruções no mais baixo nível logico, o . espace 20 # reserva 20 bytes de
binário. memória para o vetor,
declarei um vetor de 5
Código em C posições, mas vou
escolher na main quantos
Com base no código abaixo podemos ver que números
sua função é a de receber cinco valores e analisar se os números:
mesmos são pares ou impares através de uma função . asciiz "\n Digite um número: "
que contem condicionais e laços de repetições, não nos par:
aprofundaremos no programa em C pois não é o escopo . asciiz " E um número par\n"
do trabalho. impar1:
. asciiz " E um número Ímpar\n"
#include<stdio.h>
#include<stdlib.h>

int parImpar(int dados[]){

int x;
for(int i = 0; i < 5; i++){ .text
x = dados[i]; j main #Pular para main (Utilizo
if((x % 2) == 0){
o J e Não o Jall pois não
printf("%d eh um numero estou interessado em
par\n", x); guardar o RA )
}
main: #//CONDIÇOES INICIAIS//
else{
printf("%d eh um numero la $s0, dados # índice do vetor [20]
impar\n", x); la $a0, numeros # carrego endereço inicial
1

1
Código em Linguagem de Máquina LT34E – Arquitetura e Organização de Computadores

de números li $v0, 1 # se o bne não for

atendido continua
li $t0, 0 # incrementador do vetor move $a0, $t1
syscall # imprime o numero
loop:
li $v0, 4 li $v0, 4
la $a0, numeros la $a0, par
syscall # imprimo mensagem syscall # imprime mensagem par
solicitando numero
addi $t0, $t0, 4 # incrementa posição do
li $v0, 5 #syscall 5 para receber vetor
inteiro blt $t0, 20, loop2 # se não chegar no final
do vetor, fica no loop
syscall # lê o número e guarda jr $ra # finaliza função e retorna
em $v0 para o main

add $s1, $s0, $t0 # aponta para um impar:

endereço do vetor li $v0, 1
sw $v0, ($s1) # guarda o número no move $a0, $t1
vetor syscall # imprime o numero
li $v0, 4
addi $t0, $t0, 4 # pula para o próximo la $a0, impar1
índice do vetor (+4 syscall # imprime mensagem
bytes) impar

blt $t0, 20, loop # se não chegou no final
do vetor, fica no loop
jal parImpar # chama a função
parImpa
addi $t0, $t0, 4 # incrementa posição do
vetor
blt $t0, 20, loop2 # se não chegar no final
do vetor, fica no loop
jr $ra # finaliza função e retorna
para o main

li $v0, 10
syscall # finaliza programa

parImpar:
li $t0, 0 # incrementador do vetor
li $t3, 2 # divisor para a instrução
div usada no loop 2

loop2:
add $s1, $s0, $t0 # obtém endereço de um
índice do vetor
lw $t1, ($s1) # copia um número do
vetor para o registrador
$t1

div $t1, $t3 # divide o número por 2

(quociente: LO, resto: HI)
mfhi $t2 # copia o resto que está
no registrado LO para o
registrador $t2 Na imagem (2) temos a representação do decodificador
bne $t2, 0, impar # se o resto = 0, então é MIPS onde está sendo realizado a instrução de addi
um número impar $t0, $to, 4.

2
Código em Linguagem de Máquina LT34E – Arquitetura e Organização de Computadores

cada um dos formatos.

imagem 2: Representação do Decodificador MIPS.
Podemos notar que se trata de uma instrução
imediata e por isso o modelo em que será representada
por binário é do formato I, tendo, portanto, a seguinte
máscara.
Opcode: Código da operação.
rs: registrador do primeiro operando fonte.
rt: registrador do segundo operando fonte.
Immediate: Valor em binário que será utilizado para
realizar a operação.
Seguindo esta tabela podemos ver que temos
três tipos de instruções, as imediatas que são do tipo I,
as usuais que são do tipo R e as de jumps que são do
tipo J. Cada uma delas tem sua forma de ser
representada e cabe ao tradutor analisar e traduzir cada
uma dela para os tipos adequados.
A tabela (1) em anexo nos dá uma ideia do que
cada registrador significa, sendo utilizada o Tipo-R
como exemplo, mas nos casos Tipo-I e Tipo-J apenas
temos a presença de um valor imediato e um Endereço
consequentemente.
Para sabermos quais são os códigos de cada
operação temos a tabela (2) que nos dá em binário cada
código dos registradores, suas funções e mais abaixo
temos a tabela (3) dos Opcodes mais utilizados.
OPCODE DECIMAL BINÁRIO

ADD 32 100 000

SUB 34 100 010

OR 36 100 100

AND 37 100 101

SLT 42 101 010

Codificação das instruções
Nesta parte do trabalho transformaremos as instruções
que estão em Assembly para instruções em binário,
BNE 4 000 100
levando em consideração os tipos de cara uma delas.
Na tabela abaixo temos um exemplo de como é dado
3
Código em Linguagem de Máquina LT34E – Arquitetura e Organização de Computadores

BEQ 5 000 101 add $s1, $s0, $t0

000000 10001 10000 01000 00000

J 2 000 010 100000

JR 8 001 000
Conclusão

LW 35 100 011 Podemos ver com o projeto que o computador necessita

de algumas partes para conseguir interpretar o código
em linguagem de alto nível. Primeiramente devemos
SW 43 101 011 ter o código em C que é requisitado, o transformar para
MIPS e após isso traduzir para linguagem de maquina
que seria o binário. Assim a maquina ira analisar qual
Tabela 3: Opcodes das instruções.
tipo de instrução a utilizada pertence (Tipo-R, Tipo-I,
Tipo-J) e assim analisar suas máscaras, vendo seu
Opcode, seus registradores e no caso imediato o valor,
Agora começaremos de fato a decodificar e no caso J o endereço passado. Com todas essas
o programa em Assembly para binário: informações a maquina é capaz de executar as
instruções e realizar o que era um código de alto nível
.text em instrução de máquina.
Tipo J
j main

000010 00000100000000000000000001 Referência

Tipo I
li $t0, 0 [1] Mips, Compilando Funções e Procedimentos
no MIPS. Disponível em<
https://www.embarcados.com.br/funcoes-e-
100011 01000 000000 procedimentos-no-mips/>. Acesso em 24/05/2019
0000000000000000
Tipo R