Apresentação do PowerPoint

Exercício 11.1
„
Escreva um programa em código assembly
correspondente ao seguinte programa C.
cont=0;
for (n=0; n<32; n++) {
if [bit n = 1]
cont = cont +1;
}
NOTA: Atribua o registo $s0 a cont.
O ciclo vai contar o número de ocorrências do bitn=1 numa
palavra de 32 bits. Implemente como um procedimento com
parâmetros de entrada $a0 e o resultado em $v0.
Aula 11
1
Exercício 11.1
Estrutura do Programa
„
.data # alocação de espaço no data segment
„
Directivas space para criar buffer de
armezenamento
„
„
Directivas asciiz para armazenar strings
„
„
„
„
palavra = buffer(5)
Mens1 "\n Digite uma palavra de 4 letras:"
Mens2 "\n O número de bits é:"
Mens3 "\n“
.text # alocação de espaço no text segment
„
<< Instruções do Programa >>
Aula 11
2
Exercício 11.1
Estrutura do Programa
„
<<Instruções>>
„
„
Main
„
„
„
„
„
Preservar $ra
Imprimir mens. de
entrada de palavra
Ler string para palavra
Preparar e chamar
procedimento Contabits
Aula 11
„
„
„
Guardar em $t2 result. Contabits
Imprimir mens. de resultado
Imprimir num. de bits
Recuperar $ra
Jr $ra
3
Exercício 11.1
Estrutura do Programa
„
<<Instruções>>
„
Contabits
„
„
„
Inicializa mascara $t6 = 1
(1º Bit)
Inicializa cont. bits a 0 $s0
Ciclo:
„ AND para $t5 de
mascara c/ Palavra
„ Se $t5 = 0 vai para
label Zero
„ Incrementa cont. de bits
„ Zero:Desloca $s6 1 bit
a esquerda
Aula 11
Se $t6 != 0 volta para Ciclo
„Devolve em $v1 result.
„Jr $ra
„
4
# Arquitectura de Computadores,
# Programa que conta o número de bits que contem uma palavra de 32 bits
# lida por chamada ao sistema para ler string, indicando o nº de bits
.data
palavra: .space 5
frase1: .asciiz "\n Digite uma palavra de 4 letras:"
frase2: .asciiz "\n O número de bits é:"
enter: .asciiz "\n"
.text
main:
addi $sp, $sp, -4
# Reserva 1 posição na stack
sw $ra, 0($sp)
# Guarda $ra na stack
# Mostra frase1
addi $v0, $0, 4
# $v0=4, syscall call = 4
la $a0, frase1
# Carrega endereço da string frase1
syscall
# Escreve no monitor o pedido de nomes
# Lê string de palavra
addi $v0, $0, 8
# Ler string no buffer de endereço $a0
la $a0, palavra
# Carregue endereço de palavra $a0=end buffer
addi $a1, $0, 5
# Outro argumento de ler string (comprimento)
syscall
# Chama subrotina de chamada ao sistema
# Chama procedimento
la $t0, palavra
# Carrega em $t0= endereço de palavra
lw $a0, 0($t0)
# Carrega palavra de 4 letras em $a0
jal contabits
add $t2, $v0, $0
# Guarda em $t2 o valor retornado em $v0
Resolução
do
Exercício
11.1
Aula 11
5
# Programa que conta o número de bits que contem uma palavra de 32 bits
# Mostra frase2
addi $v0, $0, 4
# Syscall para imprimir string
la $a0, frase2
# Endereço de frase2
syscall
# Mostra número de ocorrências
addi $v0, $0, 1
# Imprimir inteiro
addi $a0, $t2, 0
# Valor do inteiro a imprimir
syscall
lw $ra, 0($sp)
addi $sp, $sp, 4
end: jr $ra
# Termina Programa
contabits:
addi $t6, $0, 1
# Bit a avaliar
add $s0, $0,$0
# Inicializa contador de bits
ciclo: and $t5, $a0, $t6 # $t5 = $a0 & $t6
beq $t5, $0, zero
# Se $t5 = 0 => bitn = 0
addi $s0, $s0, 1
# Conta os bits 1
zero: sll $t6, $t6, 1
# Desloca à esquerda 1 bit o $s6
bne $t6, $0, ciclo # Se $t6!=0 vai p/ ciclo,se $t6=0 último shift
addi $v0, $s0, 0
# Copia $s0 para $v0
jr $ra
Resolução
do
Exercício
7.1
(Cont)
Aula 11
6
Exercício 11.2
„
Escreva um programa em código assembly
que permita o deslocamento de n bits para a
esquerda de um operando de 64 bits colocado
em $t1 e $t0. O registo $t3 contém o valor do
deslocamento.
Aula 11
7
Exercício 11.2
Estrutura do Programa
„
.data # alocação de espaço no data segment
„
Directivas asciiz para armazenar strings
„
„
„
„
Mens1 "\n Indique 2 números inteiros, para
deslocar os bits:"
Mens2 "\n Indique no teclado o número de
deslocamentos (< 64):"
Mens3 "\n"
.text # alocação de espaço no text segment
„
<< Instruções do Programa >>
Aula 11
8
Exercício 11.2
Estrutura do Programa
„
<<Instruções>>
„
„
„
Main
„
„
„
„
„
„
„
„
„
„
Preservar $ra
Imprimir mens. de entrada de 2
inteiros
Ler 1 inteiro do teclado e
guardar em $t1
Ler outro inteiro do teclado e
guardar em $t0
Imprimir mens. de entrada de
num. de bits deslocam.
Ler num do teclado e guardar
em $t3 (shamt)
Se $t3 < 64 vai para label Zero
Se $t3 > 64 põe $t1 e $t0 a 0 e
salta para label End.
Zero:Se $t3 != 0 vai para label Cont.
senão vai para End.
„
„
„
„
„
„
„
„
„
„
„
„
„
„
„
Aula 11
„
Cont:Se $t3 < 32 vai para label Less32
$t4 = $t3 –32 (instr. Sub)
Inicializa var. ciclo $t8 = 0
Põe em$t1 conteúdo de $t0
G32:desloca $t1 1 bit para esq.
Incrementa $t8
Se $t8!=$t4 volta G32
Salta para End.
Less32:Inicializa var. ciclo $t8=0
Less:Transporta Bit 31 de $t1 para bit 0
de $t7 (srl de 31 bit)
desloca $t1 1 bit para esq.
desloca $t0 1 bit para esq.
Coloca bit 0 de $t7 em $t1 ($t1=$t1+$t7)
Incrementa $t8
Se $t8!=t3 volta para Less
End: Imprime $t1 ($v0=1)
Imprime nova linha
Imprime $t0 ($v0=1)
9
Jr $ra
# Arquitectura de Computadores,
# Programa que faz uma operação de deslocamento(shift)
# de n bits para a esquerda num registo de 64 bits
.data
frase1: .asciiz "\n Indique 2 números inteiros, para deslocar os bits:"
frase2: .asciiz "\n Indique no teclado o número de deslocamentos (< 64):"
enter: .asciiz "\n"
.text
main: la $a0, frase1
# Imprimir mensagem da frase1
addi $v0,$0, 4
syscall
addi $v0, $0, 5
# Ler no teclado 2 inteiros
syscall
add $t1, $v0,$0
# Guardar em $t1 o 1º inteiro
addi $v0, $0, 5
syscall
add $t0, $v0,$0
# Guardar em $t0 o 2º inteiro
la $a0, frase2
addi $v0,$0, 4
# Imprimir frase2
syscall
addi $v0, $0, 5
# Ler no teclado nº de deslocamentos=shamt
syscall
add $t3,$0, $v0
# Shamt lido pelo teclado guardado em $t3
slti $t5, $t3, 64
# Shamt < 64 ?
bne $t5, $0, zero
# Se shamt < 64 vai para zero
andi $t0, $t0, 0
# $t0 = 0, resultado é zero, se shamt>64
andi $t1, $t1, 0
# $t1 = 0, resultado é zero
j end
zero: bne $t3, $0, cont
# Se shamt !=0 vai para cont
j end
Resolução
de
Exercício
7.2
Aula 11
10
# Programa que faz uma operação de deslocamento(shift)
# de n bits para a esquerda num registo de 64 bits
cont: slti $t5, $t3, 32
# Shamt < 32?
bne $t5, $0, less32
# Se shamt < 32 vai para less32
addi $t4, $t3, 0
# $t4= shamt ( > 32)
sub $t4, $t4, 32
# $t4 = $t4 - 32 (bits mais significativos)
addi $t8,$0,0
great32:
add $t1, $0, $t0
andi $t0, $t0, 0
g32:
# shamt > 32
sll $t1, $t1, 1
# $t1 = $t1 << 1
addi $t8,$t8, 1
bne $t4, $t8, g32
j end
less32:
# shamt < 32
addi $t8,$0,0
less: srl $t7,$t0,31
# Transpõe bit 32 de $t0 para bit 1 de $t1
sll $t0, $t0, 1
# $t0 = $t0 << shamt
sll $t1, $t1, 1
# $t1 = $t1 << shamt
add $t1, $t7, $t1
# Bit 32 de $t0, post o $t7 passa para $t1
addi $t8,$t8, 1
bne $t3, $t8, less
end: addi $v0, $0, 4
# Imprime $t1
add $a0, $0, $t1
syscall
addi $v0, $0, 4
la $a0, enter
syscall
addi $v0, $0, 4
# Imprime $t0
add $a0, $0, $t0
syscall
jr $ra
Resolução
de
Exercício
7.2 (Cont)
Aula 11
11