Trabalho Prático BIP - Uniritter

Anderson Job Loeffler

Arquitetura e Organização de Computadores

Porto Alegre, quatorze de outubro de 2020

Trabalho prático BIP

1. Estudamos que a arquitetura hipotética que estamos utilizando para simular um

processador (PROCESSADOR BIP), conta com 4 tipos de processadores (BIP I, II, III e IV).
Faça um resumo, comparando os 4 modelos, e explicando o funcionamento das suas
instruções.

R: O modelo BIP I tem uma arquitetura baseada na arquitetura RISC do microcomputador

(PIC Programmable Intelligent Computer). Não possui banco de registradores, sendo
orientada a acumulador, onde as operações de transferência passam por ele. E, em algumas
operações, buscam-se operandos posicionados na memória. O formato de Instrução divide-se
em cinco bits para o código de operação (até 32 instruções) e onze bits para o operando (2048
posições de endereçamento — valores entre -1024 até +1023 contando com o zero). Contém
três registradores: PC (contador do programa); IR (registrador de instrução); ACC (o
acumulador que armazena dados durante a operação). Contém uma instrução de controle
(HLT), três instruções de transferência (STO, LD, LDI) e quatro de aritmética (ADD, ADDI, SUB,
SUBI).

O modelo BIP II -> extensão do BIP I, contendo mesmas características de arquitetura.

Diferente da BIP I, possui uma classe de instruções de desvio, usada para condicionais,
incondicionais e laços de repetição. Possui quatro registradores: PC (Controlador de
programa); IR (registrador de instrução); ACC (acumulador usado para armazenamento de
dados durante operação); SATUS (registrador de estado — usado para comparação e desvio de
condicional). O STATUS possui dois flags ativados dependendo da operação anterior. “Z” –
indica se resultado da operação da ULA foi iual a zero ou não. “N” – indica se último resultado
da ULA foi negativo ou não. O conjunto de instruções baseia-se nos do BIP I, mais sete
operações adicionais. Seis delas usam as flags “Z” e “N” (desvios condicionais, devem ser
precedidas por SUB ou SUBI) e uma de desvio incondicional (“JMP”).

O modelo BIP III -> extensão do BIP II com acréscimo de instruções com foco no suporte à
operações bit a bit. Inclusão de unidade lógica e mudanças no decodificador e junção da
unidade aritmética com unidade lógica (chamada de Unidade Funcional). As instruções lógicas
baseiam-se na BIP II com adição da classe de instruções de lógica booleana e destacamento
lógico (NOT, AND, ANDI, OR, ORI, XOR, XORI, SLL e SRL).

O modelo BIP IV -> extensão do BIP III com mesmas características de arquitetura. Foram
aderidos a antecipação de classes de instruções, de manipulação de vetores e suporte a sub-
rotinas. As instruções de controle são as mesmas do BIP III com adições das intruções: de
deslocamento lógico (SLL e SRL); manipulação de vetor (LDV e STOV); suporte a procedimentos
(RETURN e CALL).

2. Explique como funciona a pilha de instruções disponível no BIP IV. Como ela funciona.
 R: O código de operação contém cinco bits, enquanto que o operando possui onze bits. Os
modos de endereçamento são direto, indireto e imediato. Seus registradores: ACC
(acumulador); PC (controlador de programa); STATUS (registrador de status); INDR (registrador
de índice); SP (apontador do topo da pilha). O BIP IV contém 28 instruções. Os componentes
possuem uma pilha de suporte a procedimentos onde é salvo o endereço de memória da
instrução seguinte à chamada da sub-rotina em uma unidade de manipulação de vetores.

3. Considere o código assembly do BIP IV abaixo e responda:

.data
atribui_a_a : 0
atribui_b_b : 0
subtrai_r : 0
subtrai_x : 0
subtrai_y : 0
s:0
.text
JMP _PRINCIPAL
_ATRIBUI_A:
LDI 5
STO ATRIBUI_A_a
LD ATRIBUI_A_a
RETURN 0
_ATRIBUI_B:
LDI 2
STO ATRIBUI_B_b
LD ATRIBUI_B_b
RETURN 0
_SUBTRAI:
LD SUBTRAI_x
SUB SUBTRAI_y
STO SUBTRAI_r
LD SUBTRAI_r
RETURN 0
_PRINCIPAL:
CALL _ATRIBUI_A
STO SUBTRAI_x
CALL _ATRIBUI_B
STO SUBTRAI_y
CALL _SUBTRAI
STO s
HLT 0

a) O que faz o código abaixo?

R:
- Guarda um valor de subtração à variável “s”.
 - Os valores dos atributos “x” e “y” passados à função “subtrai (inteiro x, inteiro
y)” é chamado atráves de duas outras funções do modo: subtrai (atribui_a(),
atribui_b()).
- A função atribui_a() atribui o valor 5 à variavel “a”. A função atribui_b() atribui
2 à variável “b”. As duas funções retornam suas respectivas variáveis
atribuídas, e , portanto caem como valores de entrada de parâmetros na
função subtrai().
-
b) Apresente a sequência de empilhamento. Quais valores entraram e saíram, em ordem.

- R:
- JMP _PRINCIPAL;
- CALL ATRIBUI_A;
- LDI 5;
- STO ATRIBUI_A_a; -> entra valor 5 na variável ATRIBUI_A_a;
- LD_ATRIBUI_A_a;
- RETURN 0;
- STO SUBTRAI_x; -> entra valor 5 na variável de parâmetro SUBTRAI_x;
- CALL ATRIBUI_B;
- LDI 2;
- STO_ATRIBUI_B_b -> entra valor 2 na variável ATRIBUI_B_b;
- LD ATRIBUI_B_b;
- RETURN 0;
- STO SUBTRAI_y; -> entra valor 2 na variável SUBTRAII_y;
- CALL_SUBTRAI;
- LD SUBTRAI_x; -> pega valor da variável de parâmetro;
- SUB _SUBTRAI_y -> subtrai o valor da variável y de parâmetro;
- STO _SUBTRAI_r -> entra valor 3 de subtração dos dois parâmetros;
- LD SUBTRAI_r;
- RETURN 0;
- STO s -> entra valor 3 da variável de retorno SUBTRAI_r na variável s;
- HLT 0.
c) Quantas variáveis foram utilizadas durante o programa?

R: Seis variáveis usadas no programa.

d) Qual será o endereço de dados que será armazenado o resultado final deste
programa?

R: A instrução STO_s guarda o valor 3 (resultado da subtração) na variável “s”.

e) Qual o resultado final da execução do programa, que será armazenado na variável “s”?

R: Resultado da subtração de 5 por 2 chamado na função subtrai. O valor final

guardado é 3.
4. Considere o código de máquina abaixo e através das instruções e arquitetura do BIP, faça a
engenharia reversa e descubra o que o código binário realiza. Consulte a tabela de
opcodes do BIP I.

R:

O programa inicia três variáveis vazias.

Pega o valor 1 -> LDI 1;
Salva no endereço de memória 0 -> STO (variável no endereço 0);
Pega o valor 3 -> LDI 3;
Salva no endereço de memória 1 -> STO (variável no endereço 1);
Pega o valor salvo no endereço de memória 0 (igual a 1) -> LD (variável no endereço 0
-> valor 1);
Soma com o valor salvo no endereço de memória 1 (igual a 3) -> ADD (variável no
endereço 1 ->valor 3);
Salva o resultado no endereço de memória 2; -> STO (variável no endereço 2 -> valor
4);
Finaliza o programa -> HLT;

5. Considere o programa abaixo:

Se ao executarmos o programa no ambiente BIP, na leitura de a incluirmos o número
(0111111111111111) e na leitura de b, também incluirmos o número (0111111111111111),
em qual instrução assembly o programa irá exibir um erro? Que erro será exibido? Explique o
motivo deste erro.

R: O programa executa um erro na instrução: “ADD b”. O erro diz: “Valor 65534 não
pode ser representado por 16 bits. O valor excede o limite de dados que podem ser
representados pelo formato de instrução do BIP IV onde o tipo de dado é inteiro com sinal,
variando de -32768 a +32767.

6. Analise o código assembly abaixo e responda:

.data
m_i : 0
m_result : 0
m_a : 0
m_c : 0
j:0
k:0
.text
JMP _PRINCIPAL
_M:
LDI 0
STO M_result
LDI 1
STO M_i
LD M_c
STO 1000
LDI 1
STO 1001
LD M_i
PARA1:
SUB 1000
BGT FIMPARA1
 LD M_result
ADD M_a
STO M_result
LD M_i
ADD 1001
STO M_i
JMP PARA1
FIMPARA1:
LD M_result
RETURN 0
_PRINCIPAL:
LDI 3
STO k
LDI 2
STO j
LD k
STO M_a
LD j
STO M_c
CALL _M
STO k
LD k
STO $out_port
HLT 0

a) O que faz o código?

R: O código chama uma funcão “m” que multiplica o primeiro valor pelo segundo. O
primeiro valor é passado pela variável “k” e o segundo valor é passado pela variável “j”
pelos parâmetros da função (“a” e “c” respectivamente).

b) Apresente o resultado que é apresentado após o código ser executado.

R: O resultado da multiplicação das variáveis k = 3 pela variável j = 2 é 6.

 c) Identifique e explique o porquê o código foi escrito com a repetição de uma mesma
instrução, para obtenção de outra operação. Quais justificativas explicam esta
estratégia? Que relação isso tem com as arquiteturas RISC e CISC e o conjunto de
instruções de uma arquitetura?

R: O BIP IV utiliza uma arquitetura RISC, portanto não possui o comando de

multiplicação, utiliza-se, portanto, da sequência de somas para chegar ao produto de
dois valores. A arquitetura RISC em oposição à CISC, possui menos instruções, porém a
execução dessas instruções é mais rápida.

7. Escreva um programa que leia um número e eleve este número ao quadrado. Use sub-
rotinas. Após escrever e compilar o programa, insira o valor 5, e indique quantas vezes a
instrução ADD será executada para apresentar o valor de 5²?

R: Foram executadas 10 vezes o comando ADD, pois para que a subrotina do comando
“para” do portugol fosse executada cinco vezes, foi preciso adicionar um valor em um
endereço de memória que fizesse uma “contagem”. Dentro de cada uma dessas cinco
execuções, fez-se a soma de 5 ao resultado anterior. Em resumo, houveram cinco rotinas
de “5 + resultado”.

8. Considere o programa abaixo:

Ao simularmos este programa no BIPIDE, ele não executa conforme o esperado, mas também
não apresenta erro. Simplesmente termina o programa sem completar todo o vetor. Simule e
analise a após responda qual foi o motivo que fez isso ocorrer. Dica: analise o comportamento
da memória de dados.

R: Não existirão endereços de memória suficientes para guardar todos os valores dos
endereços dos vetores, mais as variáveis e endereços de sub rotinas.

9. Considere o código abaixo

Ao simularmos, ocorrerá um erro. Por qual motivo este erro ocorre?

R: Sente caso, não sobram endereços de memória mesmo sem os endereços utilizados para
subrotinas. Portanto o programa mostra o erro.

10. Considere o código abaixo:

procedimento principal()

declaracoes

inteiro vetor[2], i, j, aux

inicio

para i <- 0 ate 1 passo 1

vetor[i]<-i

fimpara

fim

Após a sua compilação, a simulação do código executa 38 instruções (do código assembly).
Com auxílio do simulador do BIPIDE, descreva o passo a passo de cada instrução, comentando
o que ocorreu em cada um dos passos. Não esqueça de comentar o estado dos registradores
em cada passo e se houve transferência da memória ou para a memória.

Utilize o simulador, com a opção de passo a passo (Pausa e Próximo).

R:

.text

_PRINCIPAL:

LDI 0 -> valor 0 carregado para o acumulador.

STO i -> valor do acumulador passado para a variável i.

LDI 1 -> valor um passado para o acumulador.

STO 1000 -> valor do acumulador passado para o endereço de memória 1000.

LDI 1 -> valor 1 passado para o acumulador.

STO 1001 -> valor do acumulador passado para o endereço de memória 1001.

LD i -> valor da variável i passado para o acumulador

PARA1:

SUB 1000 -> valor subtraído do acumulador para ver se a subrotina “para” será executada
novamente.

BGT FIMPARA1 -> atualiza o valor do registrador caso o resultado da operação anterior na
ULA tenha sido maior que zero. (Nesse caso o foi igual a -1).

LD i -> pega o valor da variável e joga no acumulador.

STO 1002 -> pega o valor do acumulador e joga na posição 1002 de memória.

LD i -> pega o valor de i e joga no acumulador.

STO 1003 -> guardo o valor do acumulador na posição 1003 de memória.

LD 1002 -> pega o valor da posição 1002 de memória e joga no acumulador.

STO $indr -> armazena o conteúdo do acumulador em uma posição da memória.

LD 1003 -> pega o valora da posição 1003 da memória e joga no acumulador.

STOV vetor -> armazena o conteúdo do acumulador em uma posição da memória definida
pelo operando somado ao conteúdo do registrador INDR.

LD i -> pega o valor armazenado na variável i e joga no acumulador.

ADD 1001 -> carrega o valor da posição de memória 1001 e soma com o valor do
acumulador, salva o resultado no acumulador.

STO i -> salva o valor do acumulador na variável i.

JMP PARA1 -> atualiza o valor do registrador PC com o endereço de uma instrução para
realizar um desvio incondicional.

PARA1:

SUB 1000 -> valor subtraído do acumulador para ver se a subrotina “para” será executada
novamente.

BGT FIMPARA1 -> atualiza o valor do registrador caso o resultado da operação anterior na
ULA tenha sido maior que zero. (Nesse caso o valor foi igual a zero).

LD i -> pega o valor da variável e joga no acumulador.

STO 1002 -> pega o valor do acumulador e joga na posição 1002 de memória.

LD i -> pega o valor de i e joga no acumulador.

STO 1003 -> guardo o valor do acumulador na posição 1003 de memória.

LD 1002 -> pega o valor da posição 1002 de memória e joga no acumulador.

STO $indr -> armazena o conteúdo do acumulador em uma posição da memória.

LD 1003 -> pega o valora da posição 1003 da memória e joga no acumulador.

 STOV vetor -> armazena o conteúdo do acumulador em uma posição da memória definida
pelo operando somado ao conteúdo do registrador INDR.

LD i -> pega o valor armazenado na variável i e joga no acumulador.

ADD 1001 -> carrega o valor da posição de memória 1001 e soma com o valor do
acumulador, salva o resultado no acumulador.

STO i -> salva o valor do acumulador na variável i.

JMP PARA1 -> atualiza o valor do registrador PC com o endereço de uma instrução para
realizar um desvio incondicional.

PARA1:

SUB 1000 -> valor subtraído do acumulador para ver se a subrotina “para” será executada
novamente.

BGT FIMPARA1 -> atualiza o valor do registrador caso o resultado da operação anterior na
ULA tenha sido maior que zero. (Nesse caso o foi igual a -1).

FIMPARA1:

HLT 0 -> encerra a aplicação.

11. Analise o código assembly do BIP (abaixo) e responda o que faz o programa (algoritmo) e
qual o resultado final é apresentado ao final da execução do programa.

.data

m_i : 0

m_result : 0

m_a : 0

m_c : 0

s_n : 0

k:0

.text

JMP _PRINCIPAL

_M:

LDI 0

STO M_result

LDI 1
 STO M_i

LD M_c

STO 1000

LDI 1

STO 1001

LD M_i

PARA1:

SUB 1000

BGT FIMPARA1

LD M_result

ADD M_a

STO M_result

LD M_i

ADD 1001

STO M_i

JMP PARA1

FIMPARA1:

LD M_result

RETURN 0

_S:

LD S_n

STO M_a

LD S_n

STO M_c

CALL _M

RETURN 0

_PRINCIPAL:

LDI 3

STO S_n

CALL _S

STO $out_port
 HLT 0

R: O programa eleva um número ao quadrado. Nesse caso, eleva 3 ao quadrado. O resultado é

9. Abaixo segue o código em portugol:

declaracoes

inteiro i, result

inicio

result <- 0

para i <- 1 ate c passo 1

result<-result+a

fimpara

retornar result

fim

inteiro s(inteiro n)

inicio

retornar m(n,n)

fim

procedimento principal()

declaracoes

inteiro k

inicio

escreva(s(3))

fim

Obs: a variável “k” não é usada mas é declarada.