PRÁCTICA 1

memoria
ARQUITECTURA DE COMPUTADORES
ALEJANDRO GARCÍA BELMONTE
Actividad 1
Probamos a modificar el contenido de registros y observamos que no podemos
cambiar ni $0 ni $31 ni $pc:

Probamos entonces a introducir un valor negativo, en este caso el -12 que en

hexadecimal en complemento a dos es FFFFFFF4.

Como podemos observar no hay ningún tipo de problema al introducir estos

valores.

2
Cuestión 1
En el MIPS, la representación de números utiliza el complemento a dos. Para un
registro de 32 bits, el rango de valores va desde el mayor negativo hasta el mayor
positivo.
El mayor positivo que puede contener un registro de 32 bits en hexadecimal es
0x7FFFFFFF.
El mayor negativo que puede contener un registro de 32 bits en hexadecimal es
0x80000000.

3
Cuestión 2
La instrucción addi $10, $8, 5 realiza la suma de los valores 5 y el valor que
contenga el registro $8 y lo almacena en el registro $10.

Código op (6bits) Rs (5bits) Rt (5bits) K

0010 00 01 000 0 1010 0000 0000 0000 0101

En el primer campo de 6 bits se almacena la instrucción en este caso la suma de rs

y el número K. En los siguientes se almacena los valores de los registros fuente y
destino, 8 y 10 ambos en binario y con 5 bits. Finalmente, en el último campo se
almacena el complemento a dos de la constante a sumar, en este caso 5

En hexadecimal la instrucción quedaría como: 0x210a0005

4
Actividad 2
- En este caso al indicar que la dirección por defecto es la 0x00400000, la
primera instrucción se almacenará ahí, en cambio las siguientes se irán
almacenando en la posición de la instrucción anterior +4, veámoslo en una
imagen:

- La codificación de las instrucciones en código máquina son las siguientes:

Veamos las 3 instrucciones por separado:

- 210a0005 en binario: 001000 00010 01010 0000000000000101
Op (6 bits): 001000 en decimal es 16.
rs (5 bits): 01010 en decimal es 10.
rt (5 bits): 00010 en decimal es 2.
K (16 bits): 0000000000000101 en decimal es 5.
Por lo tanto, la instrucción addi en formato decimal es: 16, 10, 2, 5.
- 20aa0004 en binario: 001000 00101 10101 0000000000000100
Op (6 bits): 001000 en decimal es 16.
rs (5 bits): 10101 en decimal es 21.
rt (5 bits): 00101 en decimal es 5.

5
K (16 bits): 0000000000000100 en decimal es 4.
Entonces, la instrucción addi en formato decimal es: 16, 21, 5, 4.
- 20c4000c en binario: 001000 00110 00100 0000000000001100
Op (6 bits): 001000 en decimal es 16.
Rs (5 bits): 00110 en decimal es 6.
rt (5 bits): 00100 en decimal es 4.
K (16 bits): 0000000000001100 en decimal es 12.
Por lo tanto, la instrucción addi en formato decimal es: 16, 6, 4, 12.

Para todas, el código op es 16, que indica la suma instantánea.

- Observamos el valor de PC:

Como podemos ver este valor es constante y no ha cambiado, indica el lugar de la

memoria por defecto en el que se guardarán las instrucciones realizadas
siguientes.

6
Actividad 3
Lo que está ocurriendo aquí es que intentamos sumar a un número como es el
7fffffff, 011111111… otro número y al hacer eso estaríamos produciendo overflow
ya que el 7fffffff es el positivo más grande que puede ser representado en un entero
con signo de 32 bits.

7
Cuestión 3
Si quisiésemos sumarle al registro $8, 25, y quisiésemos alcanzar el máximo con
esta suma, tendríamos que restarle al máximo representable 25, por lo que 7fffffff
-25 = 2147483647 -25 = 2147483622. Pasamos ese número a hexadecimal,
7FFFFFE6 y será el valor máximo que podrá tener $8 para que al sumarle 25, no
aborte la operación.
Véase con una imagen:
Al ejecutar la instrucción: addi $9, $8, 25, teniendo en $8=0x7fffffe6, el registro 9
quedaría como máximo y la instrucción se ha ejecutado correctamente.

8
Actividad 4
Si quisiésemos dar un valor inicial a $8 podríamos ejecutar la siguiente instrucción:
addi $8, $zero, K
De esta manera indicando un valor de K podríamos inicializar $8.
Para guardar este resultado en $12, podríamos añadir esta instrucción:
addi $12, $8,0
Si quisiésemos restar simplemente sumaríamos el complemento a dos del número
que deseas restar.

9
Cuestión 4
Para realizar la operación $8 = $8 - 1 utilizando la instrucción addi, podemos
restar 1 sumándole el complemento a dos de 1 en 32 bits (que es -1). Podría
hacerse tal que así:
addi $8, $8, -1
La codificación binaria:
Op (addi): 001000.
Rs ($t8): 01000.
Rt ($t8): 01000.
K: 11111111111111111111111111111111 en binario.
La instrucción addi en binario sería así:
001000 01000 01000 11111111111111111111111111111111.

10
Cuestión 5
Utilizando el convenio de registros, el programa inicial quedaría así:
addi $t1, $t0, 25
addi $t2, $t0, 5
Al ejecutarlo el programa se vería tal que así:

11
Actividad 5
Esto es lo que ocurre al ejecutar el programa:

Lo que ha ocurrido es que el programa ha detectado un overflow y el programa ha

continuado con la operación, dando un resultado incorrecto. En caso de que el
programador esté trabajando con números binarios naturales el resultado si sería
correcto ya que no existirían las restricciones del complemento a dos en 32 bits.

12
Cuestión 6
El código que utiliza convenio de registros para las operaciones indicadas es:
Addi $t4, $zero, 5
Addi $t2, $zero, 8
Addi $t5, $t4, 10
Addi $t2, $t2, -4
Addi $t6, $t5, -30
Addi $t7, $t2, 0
Ejecutamos y comprobamos que cumple las condiciones indicadas:

13
Cuestión 7
Probamos a ejecutar el Código anterior con instrucciones addiu:
Addiu $t4, $zero, 5
Addiu $t2, $zero, 8
Addiu $t5, $t4, 10
Addiu $t2, $t2, -4
Addiu $t6, $t5, -30
Addiu $t7, $t2, 0

Ocurre exactamente lo mismo ya que las instrucciones addiu solo se diferencian de

las addiu en que si ocurre overflow, el programa debe seguir ejecutándose y en
este caso no ocurre, así que el resultado es el mismo.
El código de la instrucción addiu es: 001001.

14
Codificamos en binario la instrucción addiu $v0, $zero, 1

- Op (addiu): 001001.
- Rt: 00000
- Rs: 01000
- K: 000000000000001
La instrucción en binario sería: 001001 00000 01000 00000000000001.

15