Relatório

[pic 1]

Arquitetura de Computadores I – Trabalho de Aula 20/03

Exercícios

1. Adicione comentários para o seguinte código MIPS e descreva em uma frase o que é calculado. Assume-se que $a0 e $a1 são usados para a entrada e ambos são inicializados contendo os inteiros a e b, respectivamente. Assume-se que $v0 é usado para a saída.

add $t0, $zero, $zero   #inicializa t0 com valor zero

loop:                beq $a1, $zero, finish  #testa se a1 é igual a zero, senão pula

add $t0, $t0, $a0           # soma t0 com a0 em t0

sub $a1, $a1, 1         # diminiu 1 de a1 em a1

j loop                  # vai para a linha loop

finish:         addi $t0, $t0, 100      # soma t0 com 100 em t0

add $v0, $t0, $zero     # sooma t0 com zero em v0

                                  # se a == 0, retorna 100

                                  # senão irá dobrar o valor de b, a cada loop, e retornara esse valor mais 100.

1. O fragmento de código a seguir processa dois vetores e produz um valor importante no registrador $v0. Assume-se que cada vetor consiste de 2500 palavras indexadas de 0 a 2499, que o endereço base do array está gravado em $a0 e $a1 respectivamente, e os seus tamanhos (2500) são gravados em $a2 e $a3, respectivamente. Adicione comentários para o código e descreva em uma frase o que esse código faz. Especificamente, o que será retornado em $v0?

sll $a2, $a2, 2                 # multiplica por 4

sll $a3, $a3, 2

add $v0, $zero, $zero # inicializa com zero

add $t0, $zero, $zero

outer:        add $t4, $a0, $t0         #t4 recebe a soma do t0 com a0

lw $t4, 0($t4)                 # carrega em t4 o valor na posição zero

add $t1, $zero, $zero         # inicializa t1 com zero

inner:         add $t3, $a1, $t1         # t3 recebe a soma de a1 com t1

lw $t3, 0($t3)                 # carrega em t4 o valor na posição zero

bne $t3, $t4, skip         # se t3 diferente de t4 então pula skip

addi $v0, $v0, 1                 # soma 1

skip:         addi $t1, $t1, 4                 # soma 4

bne $t1, $a3, inner         # se t1 diferente de a3 então pula inner

addi $t0, $t0, 4                 # soma 4

bne $t0, $a2, outer         # se t0 diferente de a2 então pula outer

# Verifica quantas “palavras” são iguais

  E conta em v0.

1. Dado o código em C abaixo, qual código em assembly MIPS poderia substitui-lo?

int a = 5, b = 10;

if (a + a == b) {

a = 0;

} else {

b = a - 1;

}

Addi        $s0, $s0, 5

Addi        $s1, $s1, 10

Add        $t0, $s0, $s0

Bne        $t0, $s1, L1

Add        $s0, $zero, $zero

J        L2

        L1        subi        $s1, $s0, 1

        L2

1. Dado o código em C abaixo, qual código em assembly MIPS poderia substitui-lo?

p[0] = 0;

int a = 2;

p[1] = a;

p[a] = a;

#p = s0 a = s1

add         $t0, $zero, $zero

Sw        $t0, 0($s0)                        #p[0]=0

Addi        $s1, $zero, 2                        # a = 2

sw        $s1, 4($s0)                        # p[1]= a

add        $t1, $s0, $s1                        # t1 recebe endereço de s0+s1

sw        $s1, 0($t1)                        # p[a] = a

1. Dado o código em C abaixo, qual código em assembly MIPS poderia substitui-lo?

int a=4, b=5, c=6, z;

z = a+b+c+10;

addi        $s0, $zero, 4                #a = 4

addi        $s1, $zero, 5                #b = 5

addi        $s2, $zero, 6                #c = 6

add        $s3, $s0, $s1                #z = a + b

add        $s3, $s3, $s2                #z = z + c

addi        $s3, $s3, 10                #z = z + 10

1. Dado o código em C abaixo, qual código em assembly MIPS poderia substitui-lo?

beq        $s0, $zero, Ret0[pic 2]

Addi        $t2, $zero, 1

beq        $s0, $t2, Ret1

←

Beq         $s0, $zero, RetF

←

J        Loop