Ejercicios
Para la realización
de los siguientes ejercicios, use el simulador asignado para la arquitectura
MIPS (cuando el ejercicio lo permita). Cuando sea conveniente o necesario, haga
las suposiciones correspondientes. También, se permite el uso de
pseudoinstrucciones.
1.
Para el siguiente fragmento de código C, ¿Cuál
es el correspondiente código en ensamblador MIPS?
f = g + (h - 5)
Solución:
f = $s0 g
= $s1 h = $s2
add $s0, $s0, $s1
addi $t0, $s2, -5
add $s0, $s0, $t0
2.
Para el siguiente fragmento de código en
ensamblador MIPS, ¿Cuál es el correspondiente código en lenguaje C?
add f, g, h
add d, i, f
sub b, f, d
Solución:
Procedimiento:
f = (g+h)
d = (i+g+h)
Resultado:
b = f – d
ó b = (g+h) - (i+g+h)
3. Para el siguiente fragmento de código C, ¿Cuál
es el correspondiente código en ensamblador MIPS?
B[8] = A[i-j]
Solución:
B[0] = $s0 A[0]
= $s1 i = $s2 j = $s3
sub $t0, $s2, $s3
add $t0, $t0, $t0
add $t0, $t0, $t0
add $t0, $s1, $t0
lw $t1, 0($t0)
sw $t1, 32($s0)
4. Para el siguiente fragmento de código en
ensamblador MIPS, ¿Cuál es el correspondiente código en lenguaje C?
sll $t0,
$s0, 2 # St0 = f * 4
add $t0,
$s6, $t0 # $t0 = &A[f]
sll $t1,
$s1, 2 # $t1 = g * 4
add $t1,
$s7, $t1 # $t1 = &B[g]
lw $s0,
0($t0) # f = A[f]
addi $t2,
$t0, 4
lw $t0,
0($t2)
add $t0,
$t0, $s0
sw $t0, 0($t1)
Solución:
Procedimiento:
f = A[f]
t2 = dA[f + 1]
t1 = dB[g]
t0 ó A[f + 1] = A[f + 1] + A[f]
Resultado:
B[g] = A[f + 1] + A[f]
5. La siguiente tabla muestra un arreglo de 32
bits almacenado en memoria:
Address
|
Data
|
24
|
2
|
28
|
4
|
32
|
3
|
36
|
6
|
40
|
1
|
a.
Implemente código C
que ordene el arreglo.
b.
Escriba el código
MIPS correspondiente al algoritmo en código C del apartado a.
Solución:
a.
Suponiendo que el
arreglo fue declarado como: A[].
Y declaramos cuatro
variables: a,b,c,d.
a = A[1] b = A[2] c = A[4] d
= A[5]
Entonces…
A[1] = d A[2] = a A[4] = b A[5]
= c
b.
a = $s0 b
= $s1 c = $s2 d = $s3 A[] = $s4
sw $s0 ,
0($s4)
sw $s1 ,
4($s4)
sw $s2 ,
12($s4)
sw $s3 ,
16($s4)
lw $s3 ,
0($s4)
lw $s0 ,
4($s4)
lw $s1 ,
12($s4)
lw $s2 ,
16($s4)
6.
Muestre
cómo el valor 0xabcdef12 es almacenado en memoria.
a. En un esquema de memoria Little Endian.
b.
En un
esquema de memoria Big Endian.
Solución:
a.
Dirección
|
0000
|
0001
|
0010
|
0011
|
Byte
|
12
|
ef
|
cd
|
ab
|
b.
En Big Endian el valor
más significante en este caso, ab, se almacena en la posición más pequeña:
Dirección
|
0000
|
0001
|
0010
|
0011
|
Byte
|
Ab
|
Cd
|
Ef
|
12
|
7. Traslade el valor 0xabcdef12 a decimal.
Solución:
2 * 16^0 = 2
1 * 16^1 = 16
f (15) * 16^2 = 3840
e (14) * 16^3 = 57,344
d (13) * 16^4 = 851,968
c(12) * 16^5 = 12,582,912
b(11) * 16^6 = 184,549,376
a(10) * 16^7 = 2,684,354,560
Sumando todos los resultados: 2,882,400,018
8.
Traslade
el siguiente código MIPS a código C.
addi $t0, $s6, 4
add $t1, $s6, $zero
sw $t1, 0($t0)
lw $t0, 0($t0)
add $s0, $t1, $t0
Solución:
Procedimiento:
t0 = dA[1]
t1 = A[0]
A[1] = A[0]
t0 = A[1]
s0 = A[0] + A[1]
Resultado:
A[1] = A[0]
b =
A[0] + A[1]
9. Traduzca el código MIPS del ejercicio
anterior en su correspondiente versión de código máquina, identificando cada
uno de sus campos.
Solución:
Op
|
rs
|
rt
|
rd
|
add/sha/con
|
funct
|
001000
|
10110
|
01000
|
0000000000000100
|
||
000000
|
10110
|
00000
|
01001
|
n.a
|
100000
|
101011
|
01000
|
01001
|
0000000000000000
|
||
100011
|
01000
|
01000
|
0000000000000000
|
||
000000
|
01001
|
01000
|
10000
|
n.a
|
100000
|
10. Asuma que los registros $s0 y $s1 contienen
respectivamente los valores 0x80000000 y 0xD0000000:
a. ¿Cual es el valor de $t0 para el siguiente
código ensamblador?
add $t0, $s0, $s1
b. ¿El contenido de $t0 es el resultado de la
operación, o hay overflow?
c. ¿Cuál es el contenido de $t0 para el
siguiente código MIPS?
add $t0, $s0, $s1
add $t0, $t0, $s0
Solución:
a.
Convertimos los valores hexadecimales a
decimales:
0 = 0000
0 = 0000
0 = 0000
0 = 0000
0 = 0000
0 = 0000
0 = 0000
0 = 0000
8 = 1000 Resultado:
= 1000 0000 0000 0000 0000 0000 0000 0000
0 = 0000
0 = 0000
0 = 0000
0 = 0000
0 = 0000
0 = 0000
0 = 0000
0 = 0000
D = 1011 Resultado:
= 1101 0000 0000 0000 0000 0000 0000 0000
Debido a que estamos usando una operación
add y el tamaño de los valores supera el limite, de los registros de 32bits, se
da el caso de un overflow, asi que no hay ningún valore en el registro $t0.
b.
Se da el caso de un overflow.
c.
Sucede los mismo que el inciso a, se da el
caso de un overflow y no hay valor para $t0.
11. Traduzca la siguiente instrucción máquina a
ensamblador ¿De qué tipo es?
0000 0010 0001 0000 1000 0000 0010 00002
Solución:
Dado que los primeros 6 bits son 0s, solo
puede ser una instrucción de tipo R.
Por lo tanto, podemos analizar libremente
los últimos 6 bits para identificar su
función:
100000 – Equivale al número de función de la
instrucción add.
000000
|
10000
|
10000
|
10000
|
00000
|
100000
|
add
|
$s0
|
$s0
|
$s0
|
n.a
|
32
|
add $s0, $s0, $s0
12. Proporcione la representación hexadecimal
de la siguiente instrucción:
sw $t1,32($t2)
Solución:
Primero lo convertimos a binario:
sw – 101011
$t2 – 01010
$t1 – 01001
32 - 0000000000100000
Agrupamos en grupos de cuatro:
1010 1101 0100 1001 0000 0000 0010 0000
Convertimos la representación binaria a
hexadecimal: 0xAD490020
13. Proporcione el tipo, instrucción en
lenguaje ensamblador, y la representación binaria de la instrucción descrita
por los siguientes campos de instrucción MIPS:
op = 0, rs = 3, rt = 2, rd = 3, shamt = 0, funct = 34
Solución:
Que sea la función número 34 y traducido a
hexadecimal Ox22, si consultamos con la tabla encontramos que es la operación
“sub”.
Traduciendo a lenguaje ensamblador:
rs = 3, equivale al registro $v1
rt = 2, equivale al registro $v0
rd = 3, equivale al registro $v1
Por lo tanto la operación en leguaje
ensamblador es: sub $v1, $v1, $v0
Traduciendo a lenguaje binario:
op =
0 a binario: 000000
rs = 3 a binario : 00101
rt = 2 a binario : 00010
rd = 3 a binario : 00101
shamt = 0 a binario: 000000
funct = 34 a binario: 100010
Ordenando: 000000001010001000101000000100010
14. Proporcione el tipo, instrucción en
lenguaje ensamblador, y la representación binaria de la instrucción descrita
por los siguientes campos de instrucción MIPS:
op = 0x23, rs = 1, rt = 2, const = 0x4
Solución:
Que sea la opcode número 0x23, si
consultamos con la tabla encontramos que es la operación “lw”.
Traduciendo a lenguaje ensamblador:
rs = 1, equivale al registro $at
rt = 2, equivale al registro $v0
const = 0x4, equivale a la constante decimal
4
Por lo tanto la operación en leguaje
ensamblador es: lw $v0, 4($at)
Traduciendo a lenguaje binario:
op =
0x23 a binario: 100011
rs = 1 a binario : 00001
rt = 2 a binario : 00010
const = 0 a binario: 00000000000000000000000000000100
Ordenando: 10001100001000100000000000000011
15. Asuma que n un procesador MIPS, se expande
la cantidad de registros de 32 a 128. ¿Cómo afectaría este cambio el tamaño de
los campos de una instrucción MIPS de tipo Registro?
Solución:
Los 32 registros, numerados desde 0 a 31, pueden ser
escritos en binario desde 00000 a 11111, respectivamente. Si se ampliara la
cantidad de registros a 128, los cinco dígitos binarios no serian suficientes
para enumerar los registros a partir del numero 32. Por lo tanto seria
necesario añadir dos bits, de manera que el numero binario mas alto que
podríamos escribir seria 1111111, cuyo equivalente decimal es 127.
16. Asuma los siguientes contenidos de
registros:
$t0 = 0xAAAAAAAA, $t1 = 0x12345678
a. ¿Cuál es el contenido de $t2 después de
operar las siguientes instrucciones?
sll $t2, $t0, 8
or $t2, $t2, $t1
b. ¿Cuál es el contenido de $t2 después de
operar las siguientes instrucciones?
sll $t2, $t0, 4
andi $t2, $t2, −1
17. Asuma que $t0 contiene el valor 0x00101000
¿Cuál es el valor de $t2 después de ejecutar las siguientes instrucciones?
...
slt $t2, $0, $t0
bne $t2, $0, ELSE
j DONE
ELSE:
addi $t2, $t2, 2
DONE:
...
Solución:
Como el valor de $t0 es claramente mayor que
el valor de $0 (zero) el comando slt hará que $t2 tome el valor de 1.
Luego el comando bne intenta verificar si $t2
y $0 son distintos. Como esta condición se cumple entonces la instrucción salta
hacia el ELSE, donde el comando addi le suma 2 al valor de $t2.
Por lo tanto el valor final de $t2 es 3.
18.
Considere
el siguiente ciclo MIPS:
...
LOOP:
slt $t2, $0, $t1
beq $t2,
$0, DONE
subi $t1, $t1, 1
addi $s2, $s2, 2
j LOOP
DONE:
...
a. Asuma que el registro $t1 es inicializado a
10. ¿Cuál es el valor del registro $s2 asumiendo que $s2 es inicializado a
cero?
Solución:
Asumiendo que subi existe, ya que de lo
contrario esto causaría un error de compilación:
Hacemos una tabla donde anotamos los valores
de cada registro al FINAL de un ciclo.
Numero de Ciclo
|
Valor de $t1
|
Valor de $t2
|
Valor de $s2
|
1
|
9
|
1
|
2
|
2
|
8
|
1
|
4
|
3
|
7
|
1
|
6
|
4
|
6
|
1
|
8
|
5
|
5
|
1
|
10
|
6
|
4
|
1
|
12
|
7
|
3
|
1
|
14
|
8
|
2
|
1
|
16
|
9
|
1
|
1
|
18
|
10
|
0
|
1
|
20
|
11
|
0
|
0
|
20
|
El valor final del registro $s2.
19. Implemente en código ensamblador el
siguiente código escrito en C:
No hay comentarios:
Publicar un comentario