UNIVERSIDADE FEDERAL DE CAMPINA GRANDE

CENTRO DE CIÊNCIAS E TECNOLOGIA - DEPARTAMENTO DE ENGENHARIA ELÉTRICA

DISCIPLINA: ARQUITETURA DE SISTEMAS DIGITAIS (2017.2) Data: 28/11/2017
Aluno(a):__________________________________________________________ Matrícula: _________________

1ª Avaliação Escolar

1. Apresente o valor de out quando pronto for para 1, para as entradas ma e mb correspondentes ao penúltimo e último
dígito de sua matrícula, respectivamente. Suponha que inicio ficou um tempo em 1 e foi para zero e vários ciclos de clk
ocorreram. (2,0)

module Booth(input [3:0] ma, mb, input inicio, clk, output reg [7:0] out, output reg pronto);
reg [2:0] bit;
reg d;
always @( posedge clk )
if(inicio ) begin pronto = 0; bit = 4; out = { 4'd0, mb }; d = 0; end
else if( bit != 0 ) begin
case ( {out[0],d} )
2'b01: out[7:4] = out[7:4] + ma;
2'b10: out[7:4] = out[7:4] - ma;
endcase
d = out[0];
out = { 1'b0, out[7:1] };
bit = bit - 1;
if (bit == 0) pronto = 1;
end
endmodule

2. Suponha o processador MIPS em estudo tenha palavra de 8 bits. Preencha a tabela com o valor do registrador $2 após a
execução do programa abaixo (quando chega no endereço 18h), para cada valor de $1 no início do programa dado na tabela.
X é o último dígito da sua matrícula. Apresente os valores exclusivamente em hexadecimal (2,0).
Penalidade se não apresentar em hexadecimal (-1,0).

00: ADDI $2, $0, X

04: ADDI $4, $0, 10 $1 início 1 2 3 4 5
08: ADDI $1, $1, 1 $2 final
0C: ADD $2, $2, $1
10: SLT $3, $1, $4
14: BNE $3, $0, -4 #(para 08)
18: ...

3. Implemente uma sub-rotina em Assembly MIPS que realize a contagem de bits 1s em um número de 32 bits. O número já
está em $s0 e o resultado deve ser apresentado em $s1. Por exemplo, se o número for 0x12345678, teremos 13 como
resultado da contagem de bits 1. (2,0)

4. Implemente um programa em Assembly MIPS que faça a chamada para a sub-rotina da questão anterior (mesma que não
tenha feito) para calcular a quantidade de bits 1s nos 8 últimos dígitos de sua matrícula. Deixe o resultado em $s3. (2,0)

5. Quais as limitações do processador MIPS ciclo-único que impedem que ele consiga ficar muito mais rápido do que é
atualmente? Em outras palavras, mesmo que se façam algumas alterações, porque o projeto ciclo único não consegue
executar programas em tempo muito curto? (2,0)
 Linguagem assembly MIPS simplificado para o 1º Estágio

Sintaxe da
Nome Significado Notas
instrução

Soma add $d,$s,$t $d = $s + $t Soma dois registradores, causa uma exceção no overflow
Subtrai sub $d,$s,$t $d = $s - $t Subtrai dois registradores, causa uma exceção no overflow
Soma um valor imediato a um registrador, , causa uma exceção no
Soma imediato addi $t,$s,C $t = $s + C (signed)
overflow
Carrega palavra lw $t,C($s) $t = Memória[$s + C] Carrega a palavra guardada em MEM[$s+C] e os 3 bytes seguintes
Carrega byte lb $t,C($s) $t = Memória[$s + C] (signed) Carrega o byte armazenado em MEM[$s+C].
Armazena palavra sw $t,C($s) Memória[$s + C] = $t Armazena uma palavra em MEM[$s+C] e nos 3 bytes seguintes
Armazena o primeiro quarto de um registrador (um byte) em
Armazena byte sb $t,C($s) Memória[$s + C] = $t
MEM[$s+C]
And and $d,$s,$t $d = $s & $t And bit-a-bit
And imediato andi $t,$s,C $t = $s & C
Or or $d,$s,$t $d = $s | $t Or bit-a-bit
Or imediato ori $t,$s,C $t = $s | C
Ou exclusivo xor $d,$s,$t $d = $s ^ $t
Nor nor $d,$s,$t $d = ~ ($s | $t) Nor bit-a-bit
Testa se um registrador é menor que outro. O valor é 1 se for e
Marca se menor que slt $d,$s,$t $d = ($s < $t)
zero se não.
Marca se menor que Testa se um registrador é menor do que uma constante. O valor é
sl� $t,$s,C $t = ($s < C)
imediato 1 se for e zero se não.
Vai para a instrução no endereço especificado se os dois
Desvie se igual beq $s,$t,C if ($s == $t) go to PC+4+4*C
registradores são iguais
Vai para a instrução no endereço especificado se os dois
Desvie se diferente bne $s,$t,C if ($s != $t) go to PC+4+4*C
registradores são diferentes
Salte jC PC = PC+4[31:28] . C*4 Salta incondicionalmente para o endereço especificado.
Desloque a esquerda lógico sll $d, $s $d = $s << 1 Desloca o registrador inserindo zero à esquerda.
Desloque a direita lógico srl $d, $s $d = $s >> 1 Desloca o registrador inserindo zero à direita.
Desloque a direita
sra $d, $s $d = $s >> 1, mantém sinal Desloca o registrador inserindo o bit de sinal à direita.
aritmé�co
MIPS tem 32 registradores para inteiros. O registrador $0 sempre possui o valor 0. Os registradores podem ser acessados pelo número ou por
nomes. Os nomes são: $R0 é $zero, $ra para endereço de retorno, $at para registrador reservado para o assembler, $t0 a $t9 para
registradores temporários, $s0 a $s7 para registradores gerais, $v0 a $v1 para valores de retorno, $a0 a $a3 para argumenos e $sp para a pilha.
As letras d, t, e s ficam no lugar de nomes (ou números) de registradores. C denota uma constante (valor imediato).