Práctica 2 - Assembler MIPS

Práctica 2 - Assembler MIPS
Organización del Computador 1
Verano 2014
Se deberán resolver al menos los ejercicios: 3, 6, 7, 9, 17, 22, 25 de la presente guı́a. El
resto de los ejercicios son opcionales.
Ejercicio 1 Para cada una de las siguientes instrucciones expresadas en lenguaje C
a.
b.
f = g - h;
f = g + (h - 5);
y asumiendo que f, g, h e i representan a variables enteras de 32-bits declaradas previamente:
i) Traducir a código assembler MIPS utilizando la cantidad mı́nima de instrucciones necesarias.
ii) ¿Cuántas instrucciones de assembler MIPS fueron necesarias?
iii) Si las variables f, g, h e i inicialmente poseen los valores 1, 2, 3 y 4, respectivamente,
¿Cuál es el valor final de f?
Para cada una de las siguientes instrucciones expresadas en lenguaje assembler MIPS
a.
b.
addi f, f, 4
add f, g, h
add f, i, f
i) Traducir a código C utilizando la cantidad mı́nima de instrucciones necesarias.
ii) Si las variables f, g, h e i inicialmente poseen los valores 1, 2, 3 y 4, respectivamente,
¿Cuál es el valor final de f?
Ejercicio 2 Para cada una de las siguientes instrucciones expresadas en lenguaje C
a.
b.
f = g - f;
f = i + (h - 2);
y asumiendo que f, g, h e i representan a variables enteras de 32-bits declaradas previamente:
i) Traducir a código assembler MIPS utilizando la cantidad mı́nima de instrucciones necesarias.
ii) ¿Cuántas instrucciones de assembler MIPS fueron necesarias?
iii) Si las variables f, g, h e i poseen los valores 1, 2, 3 y 4, respectivamente, ¿Cuál es el
valor final de f?
1
Para cada una de las siguientes instrucciones expresadas en lenguaje assembler MIPS
a.
b.
addi f, f, 4
add f, g, h
sub f, i, f
i) Traducir a código C utilizando la cantidad mı́nima de instrucciones necesarias.
ii) Si las variables f, g, h e i poseen los valores 1, 2, 3 y 4, respectivamente, ¿Cuál es el
valor final de f?
Ejercicio 3 Para cada una de las siguientes instrucciones expresadas en lenguaje C
a.
b.
f = - g - f;
f = g + (-f -5);
y asumiendo que f y g representan a variables enteras de 32-bits declaradas previamente:
i) Traducir a código assembler MIPS utilizando la cantidad mı́nima de instrucciones necesarias.
ii) ¿Cuántas instrucciones de assembler MIPS fueron necesarias?
iii) Si las variables f y g poseen los valores 1 y 2, respectivamente, ¿cuál es el valor final de
f?
Para cada una de las siguientes instrucciones expresadas en lenguaje assembler MIPS
a.
b.
addi f, f, -4
add i, g, h
sub f, i, f
i) Traducir a código C utilizando la cantidad mı́nima de instrucciones necesarias.
ii) Si las variables f, g, h e i poseen los valores 1, 2, 3 y 4, respectivamente, ¿Cuál es el
valor final de f?
Ejercicio 4 Para cada una de las siguientes instrucciones expresadas en lenguaje C
a.
b.
f = - g - A[4];
B[8] = A[i-j];
asumiendo que las variables f, g, h, i y j son asignadas a los registros $s0, $s1, $s2, $s3
y $s4, respectivamente, y que las direcciones iniciales de los vectores A y B se encuentran en
los registros $s6 y $s7, respectivamente:
i) Traducir a código assembler MIPS utilizando la cantidad mı́nima de instrucciones necesarias.
ii) ¿Cuántas instrucciones de assembler MIPS fueron necesarias?
iii) ¿Cuántas registros se necesitaron en cada caso?
2
Para cada uno de los siguientes códigos en lenguaje assembler MIPS
a.
b.
sll
add
add
sll
add
sll
add
lw
addi
lw
add
sw
$s2,
$s0,
$s0,
$t0,
$t0,
$t1,
$t1,
$s0,
$t2,
$t0,
$t0,
$t0,
$s4, 1
$s2, $s3
$s0, $s1
$s0, 2
$s6, $t0
$s1, 2
$s7, $t1
0($t0)
$t0, 4
0($t2)
$t0, $s0
0($t1)
#
#
#
#
#
$t0 = f * 4
$t0 = &A[f]
$t1 = g * 4
$t1 = &B[g]
$f = A[f]
asumiendo que las variables f, g, h, i y j son asignadas a los registros $s0, $s1, $s2, $s3
y $s4, respectivamente, y que las direcciones iniciales de los vectores A y B se encuentran en
los registros $s6 y $s7, respectivamente:
i) Traducir a código C utilizando la cantidad mı́nima de instrucciones necesarias.
Ejercicio 5 La tabla que se presenta a continuación muestra los valores de un vector almacenado en memoria. Asuma que la dirección inicial del vector se guarda en el registro $s6.
a.
b.
Dirección
20
24
28
32
36
Dirección
24
28
32
36
40
Dato
4
5
3
2
1
Dato
2
4
3
6
1
i) Escribir un programa en C que ordene los datos del vector de menor a mayor. Asumir
que los datos de la tabla se encuentran almacenados en una variable de tipo int[ ]
denominada Array. La máquina direcciona a byte y una palabra se encuentra compuesta
por 4 bytes.
ii) Escribir un programa en assembler MIPS que ordene los datos del vector de menor a
mayor utilizando la menor cantidad posible de instrucciones.
iii) ¿Cuántas instrucciones fueron necesarias en el caso del código assembler MIPS? En
el caso de no permitirse el uso del campo inmediato para las instrucciones lw y sw,
¿Cuántas instrucciones serı́an necesarias para realizar el ordenamiento?
Dado los siguientes números que se encuentran expresados en base hexadecimal
a.
b.
0xabcdef12
0x10203040
3
i) Traducirlos a decimal.
ii) Mostrar cómo se organizan los datos de la tabla en una máquina con un diseño littleendian. ¿Y en una máquina big-endian? Asumir que los datos son almacenados a partir
de la dirección de memoria 0.
Ejercicio 6 Para cada una de las siguientes instrucciones expresadas en lenguaje C
a.
b.
f = f + A[2];
B[8] = A[i] + A[j];
asumiendo que las variables f, g, h, i y j son asignadas a los registros $s0, $s1, $s2, $s3
y $s4, respectivamente, y que las direcciones iniciales de los vectores A y B se encuentran en
los registros $s6 y $s7, respectivamente y que los elementos de los vectores son palabras de
4-bytes:
i) Traducir a código assembler MIPS utilizando la cantidad mı́nima de instrucciones necesarias.
ii) ¿Cuántas instrucciones de assembler MIPS fueron necesarias?
iii) ¿Cuántos registros se necesitaron en cada caso?
Para cada uno de los siguientes códigos en lenguaje assembler MIPS
a.
b.
sub $s0, $s0, $s1
sub $s0, $s0, $s3
add $s0, $s0, $s1
addi $t0, $s6,
4
add $t1, $s6,
$0
sw
$t1, 0($t0)
lw
$t0, 0($t0)
add $s0, $t16, $t0
asumiendo que las variables f, g, h, i y j son asignadas a los registros $s0, $s1, $s2, $s3
y $s4, respectivamente, y que las direcciones iniciales de los vectores A y B se encuentran en
los registros $s6 y $s7, respectivamente:
i) Traducir a código C utilizando la cantidad mı́nima de instrucciones necesarias.
ii) Asumiendo que los registros $s0, $s1, $s2, y $s3 contienen los valores 0x0000000A,
0x00000014, 0x0000001E y 0x00000028, respectivamente, $s6 contiene el valor 0x00000100,
y la memoria contiene los siguientes valores:
Dirección
0x00000100
0x00000104
0x00000108
Valor
0x00000064
0x000000C8
0x0000012C
¿Qué valor toma $s0 al final de la ejecución del código assembler ?
iii) Para cada instrucción MIPS, mostrar su valor de opcode (OP), source register
(RS) y target register (RT). Para cada instrucción de tipo I-type, mostrar el valor del inmediate field y para las instrucciones de tipo R-type mostrar el valor del
destination register (RD).
4
Ejercicio 7 Dados:
a.
b.
0010 0100 1001 0010 0100 1001 0010 0100(2)
0101 1111 1011 1110 0100 0000 0000 0000(2)
i) ¿Qué número representa en base 10, asumiendo que es un entero complemento a 2?
ii) ¿Qué número representa en base 10, asumiendo que es un entero sin signo?
iii) ¿Qué número hexadecimal representa?
Dados:
a.
b.
-1(10)
1024(10)
i) Representar en binario asumiendo complemento a 2.
ii) Representar en hexadecimal asumiendo complemento a 2.
Ejercicio 8 Dados:
a.
b.
$s0 = 0x80000000(16)
$s0 = 0x00000001(16)
$s1 = 0xD0000000(16)
$s1 = 0xFFFFFFFF(16)
i) ¿Qué valor toma $t0 luego de ejecutar la siguiente instrucción assembler MIPS?
add $t0, $s0, $s1
¿$t0 contiene el resultado esperado o ha habido overf low?
ii) ¿Qué valor toma $t0 luego de ejecutar la siguiente instrucción assembler MIPS?
sub $t0, $s0, $s1
¿$t0 contiene el resultado esperado o ha habido overf low?
iii) ¿Qué valor toma $t0 luego de ejecutar las siguientes instrucciones assembler MIPS?
add $t0, $s0, $s1 add $t0, $t0, $s0
¿$t0 contiene el resultado esperado o ha habido overf low?
Dadas las siguientes instrucciones en assembler MIPS:
a.
a.
add
add
add
add
add
$s0,
$s0,
$s0,
$s0,
$s0,
$s0,
$s0,
$s0,
$s0,
$s0,
$s1
$s1
$s1
$s1
$s1
i) Asumiendo que $s0 = 0x70000000 y $s1 = 0x10000000, ¿Se obtendrá overf low?
ii) Asumiendo que $s0 = 0x40000000 y $s1 = 0x20000000, ¿Se obtendrá overf low?
iii) Asumiendo que $s0 = 0x8FFFFFFF y $s1 = 0xD0000000, ¿Se obtendrá overf low?
5
Ejercicio 9 Para cada valor del registro $s1:
a.
b.
-1(10)
1024(10)
i) Asumiendo que el registro $s0 = 0x70000000, si la instrucción add $s0, $s0, $s1 es
ejecutada, ¿Dará overf low?
ii) Asumiendo que el registro $s0 = 0x80000000, si la instrucción sub $s0, $s0, $s1 es
ejecutada, ¿Dará overf low?
iii) Asumiendo que el registro $s0 = 0x7FFFFFFF, si la instrucción sub $s0, $s0, $s1 es
ejecutada, ¿Dará overf low?
Para cada valor del registro $s1:
a.
b.
0010 0100 1001 0010 0100 1001 0010 0100(2)
0101 1111 1011 1110 0100 0000 0000 0000(2)
i) Asumiendo que el registro $s0 = 0x70000000, si la instrucción add $s0, $s0, $s1 es
ejecutada, ¿Dará overf low?
ii) Asumiendo que el registro $s0 = 0x70000000, si la instrucción add $s0, $s0, $s1 es
ejecutada, ¿Cuál es su resultado en hexadecimal?
iii) Asumiendo que el registro $s0 = 0x70000000, si la instrucción add $s0, $s0, $s1 es
ejecutada, ¿Cuál es su resultado en decimal?
Ejercicio 10 Para número binario que se presenta a continuación:
a.
b.
0000 0010 0001 0000 1000 0000 0010 0000(2)
0000 0001 0100 1011 0100 1000 0010 0010(2)
i) ¿Qué instrucción MIPS representa?
ii) ¿En qué formato está codificada la instrucción (I-type, R-type, J-type)?
iii) Si fueran bits de datos, ¿Qué número hexadecimal representan?
Para cada instrucción:
a.
b.
addi $t0, $t0, 0
sw $t1 32($t2)
i) Mostrar el número en hexadecimal que la respresenta.
ii) ¿En qué formato está codificada la instrucción (I-type, R-type, J-type)?
iii) ¿Cuál es la representación hexadecimal de los campos opcode, Rs y Rt? Para la instrucción R-type, ¿Cuál es la representación hexadecimal de los campos Rd y funct? Para
la instrucción I-type, ¿Cuál es la representación del campo inmediato?
Ejercicio 11 Dados:
a.
b.
01084020(16)
02538822(16)
6
i) ¿Qué número representa en base 2?
ii) ¿Qué número representa en base 10?
iii) ¿Qué instrucción MIPS representa?
Dados:
a.
b.
op=0, rs=3, rt=2, rd=3, shamt=0, funct=34
op=0x23, rs=1, rt=2, const=0x4
i) ¿En qué formato está codificada la instrucción (I-type, R-type)?
ii) ¿Qué instrucción MIPS describe?
iii) ¿Cuál es la representación en base 2 de la instrucción que representa?
Ejercicio 12 Dados:
a.
b.
128 registros
4 veces más instrucciones
i) Si el set de instrucciones del procesador MIPS fuera modificado, el formato de instrucción también deberı́a ser modificado. Para cada cambio sugerido arriba, mostrar el
tamaño de los campos bits de una instrucción de formato R-type . ¿Qué cantidad de
bits se necesita para cada instrucción?
ii) Si el set de instrucciones del procesador MIPS fuera modificado, el formato de instrucción también deberı́a ser modificado. Para cada cambio sugerido arriba, mostrar el
tamaño de los campos bits de una instrucción de formato I-type . ¿Qué cantidad de
bits se necesita para cada instrucción?
iii) ¿Qué instrucción MIPS representa?
iv) ¿Por qué, el cambio sugerido en la tabla anterior, podrı́a disminuir el tamaño de un
programa en assembler MIPS?
Dados:
a.
b.
01090012(16)
AD090012(16)
i) ¿Qué número representa en base 10?
ii) ¿Qué instrucción MIPS representa?
iii) ¿Qué tipo de instrucción representa (I-type, R-type, J-type)? ¿Cuáles son los valores
de los campos op y rt?
Ejercicio 13 Dados:
a.
b.
$t0 = 0xAAAAAAAA, $t1 = 0x12345678
$t0 = 0xF00DD00D, $t1 = 0x11111111
7
i) ¿Cuál es el valor de $t2 luego de ejecutar las siguientes instrucciones?
sll $t2, $t0, 44
or $t2, $t2, $t1
ii) ¿Cuál es el valor de $t2 luego de ejecutar las siguientes instrucciones?
sll $t2, $t0, 4
andi $t2, $t2, -1
iii) ¿Cuál es el valor de $t2 luego de ejecutar las siguientes instrucciones?
srl $t2, $t0, 3
andi $t2, $t2, 0xFFEF
Dados:
a.
b.
sll
andi
andi
srl
$t2,
$t2,
$t2,
$t2,
$t0, 1
$t2, -1
$t1, 0x00F0
2
i) Asumiendo que $t0 = 0x0000A5A5 y $t1 = 00005A5A ¿Cuál es el valor de $t2 luego
de ejecutar las instrucciones de la tabla?
ii) Asumiendo que $t0 = 0xA5A50000 y $t1 = A5A50000 ¿Cuál es el valor de $t2 luego
de ejecutar las instrucciones de la tabla?
iii) Asumiendo que $t0 = 0xA5A5FFFF y $t1 = A5A5FFFF ¿Cuál es el valor de $t2 luego
de ejecutar las instrucciones de la tabla?
Ejercicio 14 Sólo a efectos de mantener la numeración sincronizada con el libro.
Ejercicio 15 Dadas:
a.
b.
not $t1, $t2
// invierte bit a bit
orn $t1, $t2, $t3 // OR bit a bit de $t2, $t3
i) Las instrucciones incluidas en la tabla no se encuentran incluidas en el set de instrucciones de assembler MIPS, pero en la misma tabla se adjunta una mı́nima descripción de
lo que realizan. Dados los valores de $t2 = 0x00FFA5A5 y $t3 = 0xFFFF003C, ¿Cuál
es valor de $t1 luego de ejecutar la instrucción?
ii) La instrucciones incluidas en la tabla no se encuentran incluidas en el set de instrucciones
de assembler MIPS, las mismas pueden ser recreadas utilizando una o más instrucciones
de assembler MIPS. Mostrar un conjunto mı́nimo de instrucciones MIPS que puedan
recrear las instrucciones de la tabla.
iii) Para la secuencia de instrucciones del punto anterior, mostrar la representación a nivel
bit de cada instrucción.
8
Dadas:
a.
b.
A = B | !A;
A = C[0] << 4;
i) La tabla muestra diferentes sentencias en C que utilizan operadores lógicos. Si la posición
de memoria C[0] contiene el valor entero 0x00001234, y los valores iniciales de los
enteros A y B son 0x00000000 y 0x00002222, ¿Cuál es el valor resultante de A?
ii) Para las sentencias en C de la tabla, escribir una secuencia mı́nima de instrucciones de
assembler MIPS que realicen las mismas operaciones. Asumir que $t1 = A, $t2 = B, y
$s1 es la dirección inicial de C.
iii) Para la secuencia de instrucciones del punto anterior, mostrar la representación de cada
una a nivel de bits.
Ejercicio 16 Dados:
a.
b.
$t0 = 0010 0100 1001 0010 0100 1001 0010 0100(2)
$t0 = 0101 1111 1011 1110 0100 0000 0000 0000(2)
i) Si $t1 = 0011 1111 1111 1000 0000 0000 0000 0000(2) ¿Cuál es valor de $t2 luego
de la ejecución de las siguientes instrucciones?
ELSE:
DONE:
slt
beq
j
addi
$t2, $t0, $t1
$t2, $0, ELSE
DONE:
$t2, $0, 2
ii) Dada la instrucción slti que se muestra a continuación, ¿Para qué valores de X, si es
que existe alguno, $t2 será igual a 1?
slti $t2, $t0, X
iii) Suponga que el program counter (PC) = 0x0000 0020. ¿Es posible usar la instrucción
jump (j) de assembler MIPS para asignarle al PC la dirección de la tabla? ¿Es posible
utilizar el branch-on-equal (beq) de la instrucción assembler MIPS para asignarle al
PC la dirección de la tabla?
Dados:
a.
b.
$t0=0x00101000
$t0=0x80001000
i) ¿Cuál es valor de $t2 luego de la ejecución de las siguientes instrucciones?
ELSE:
DONE:
slt
beq
j
addi
$t2, $0, $t0
$t2, $0, ELSE
DONE:
$t2, $t2, 2
9
ii) ¿Cuál es valor de $t2 luego de la ejecución de las siguientes instrucciones?
sll
slt
$t0, $t0, 2
$t2, $t0, $0
iii) Suponga que el program counter (PC) = 0x2000 0000. ¿Es posible usar la instrucción
jump (j) de assembler MIPS para asignarle al PC la dirección de la tabla? ¿Es posible
utilizar el branch-on-equal (beq) de la instrucción assembler MIPS para asignarle al
PC la dirección de la tabla? Prestar atención al formato de las instrucciones J-type.
Ejercicio 17 Dadas:
a.
b.
subi $t2, $t3, 5
rpt $t2, loop
# R[rt] = R[rs] - SignExtImm
# if(R[rs]>0) R[rs]=R[rs]-1, PC=PC+4+BranchAddr
i) La tabla contiene instrucciones que no se encuentran incluidas en el set de instrucciones
de assembler MIPS y una descripción de su funcionamiento. ¿Por qué estas instrucciones
no han sido incluidas en el set de instrucciones MIPS?
ii) Si estas instrucciones tuvieran que ser implementadas dentro del set de instrucciones
MIPS, ¿Cuál serı́a el formato de instrucción más apropiado?
iii) Escribir la secuencia más corta de instrucciones MIPS que ejecuten la instrucción.
Dados:
a.
LOOP:
b.
DONE:
LOOP:
addi $s2, $s2, 2
subi $t1, $t1, 1
bne $t1, $0, LOOP
slt
beq
subi
addi
$t2,
$t2,
$t1,
$s2,
$0, $t1
$0, DONE
$t1, 1
$s2, 2
DONE:
i) ¿Cuál es el valor de $s2, asumiendo que inicialmente $s2=0 y $t1=10?
ii) Escribir una rutina equivalente en C. Asumir que los registros $s1, $s2, $t1, y $t2 son
representados por los enteros A, B, i y temp, respectivamente.
iii) Asumiendo que incialmente $t1=N, ¿Cuántas instrucciones MIPS son ejecutadas?
Ejercicio 18 Dados:
a.
b.
for(i=0; i<a; i++)
a+= b;
for(i=0; i<a; i++)
for(j=0; j<b; j++)
D[4*j] = i + j;
i) Dibujar un diagrama de flujo del código C
ii) Trasladar el código C a assembler MIPS. Usar la mı́nima cantidad de instrucciones
posibles. Asumir que los valores de a, b, i y j se encuentran almacenados en los registros
$s0, $s1, $t0 y $t1, respectivamente. Además, asumir que el registro $s2 contiene la
posición inicial del vector D
10
iii) ¿Cuántas instrucciones MIPS toma implementar el código C? Si las variables a y b son
inicializadas en 10 y 1 respectivamente y todos los elementos de D son inicializados en
0, ¿Cuántas instrucciones MIPS son ejecutadas al finalizar el ciclo?
Dados:
a.
LOOP:
b.
LOOP:
addi
lw
add
lw
add
addi
subi
bne
addi
lw
add
addi
addi
slti
bne
$t1,
$s1,
$s1,
$s1,
$s1,
$s0,
$t1,
$t1,
$t1,
$s1,
$s2,
$s0,
$t1,
$t2,
$t2,
$0, 50
0($s1)
$s2, $s1
4($s0)
$s2, $s1
$s0, 8
$t1, 1
$0, LOOP
$0, $0
0($s0)
$s2, $s1
$s0, 4
$t1, 1
$t1, 100
$s0, LOOP
i) ¿Cuántas instrucciones MIPS se ejecutan?
ii) Escribir una rutina equivalente en C. Asumir que los registros $t1, $s2 y $s0 son
representados por los enteros i, result y la dirección inicial del vector MemArray, respectivamente.
iii) Rescribir el ciclo para reducir la cantidad de instrucciones MIPS ejecutadas.
Ejercicio 19 Dados:
a.
b.
int fib(int n){
if (n==0)
return 0;
else if (n==1)
return 1;
else
fib(n-1) + fib(n-2);
}
int positive(int a, int b){
if (addit(a, b) >0)
return 1;
else
return 0;
}
int addit(int a, int b){
return a+b;
}
11
Conservado
Registros guardados: $s0-$s7
Registro stack pointer: $sp
Registro de dirección de retorno: $ra
Stack por encima de stack pointer
No conservado
Registros temporales: $t0-$t9
Registros de argumentos: $a0-$a3
Registros con valores de retorno: $v0-$v1
Stack por debajo de stack pointer
Cuadro 1: Que debe ser conservado y que no, en un llamado a procedimiento. Si el software
se basa en los registros frame pointer o global pointer, también deben ser conservados.
(Tabla obtenida de la Figura 2.11 del libro)
Nombre
$zero
$v0-$v1
Número de registro
0
2-3
$a0-$a3
$t0-$t7
$s0-$s7
$t8-$t9
$gp
$sp
$fp
$ra
4-7
8-15
16-23
24-25
28
29
30
31
Uso
Valor constante cero
Valores para resultados y
evaluación de expresiones
Argumentos
Temporales
Guardados
Más temporales
Global Pointer
Stack Pointer
Frame Pointer
Dirección de retorno
¿Conservado en la llamada?
n.a.
no
no
no
si
no
si
si
si
si
Cuadro 2: Convención de uso de registros MIPS. El registro 1, llamado $at, es reservado para
el ensamblador, y los registros 26-27, denominados $k0-$k1, son reservados para el sistema
operativo. (Tabla obtenida de la Figura 2.14 del libro)
i) Implementar el código C en assembler MIPS. ¿Cuántas instrucciones MIPS son necesarias para ejecutar la función?
ii) La funciones generalmente pueden ser implementadas por los compiladores in-line.
Una función in-line es cuando el cuerpo de la función es copiado dentro del espacio
de programa, eliminando la sobrecarga por la llamada a la función. Implementar en
assembler MIPS una versión in-line del código C. ¿Cuál es la reducción en cantidad
de instrucciones MIPS necesarias para ejecutar la función? Asumir que la variable n se
inicializa en 5.
iii) Para cada llamada a función, mostrar el contenido del stack luego de que la llamada
sea hecha. Asumir que el stack pointer se encuentra originalmente en la dirección
0x7FFFFFFC y sigue la convensión de registros especificada en el Cuadro 1.
La función f llama a otra función: func, cuyo código C (de la función func) ya ha sido compilada en otro módulo usando la convención de llamadas de MIPS del Cuadro 2. La declaración
de la función func es int func(int a, int b); El código de la función f se detalla a continuación:
a.
b.
int f(int a, int b, int c, int d){
return func(func(a,b),c+d);
}
int f(int a, int b, int c, int d){
if(a+b>c+d)
return func(a+b,c+d);
return func(c+d,a+b);
}
12
i) Trasladar la función f a assembler MIPS, usando la convención de llamadas MIPS del
Cuadro 2. Si necesita utilizar los registros $t0 a $t7, utilizar primero los de menor
numeración.
ii) ¿Puede utilizarse la optimización tail-call en esta función? Si la respuesta es no,
justificar. Si la respuesta es sı́, ¿Cuál es la diferencia, en cantidad de instrucciones
ejecutadas en f, con y sin la optimización?
iii) Justo antes de que la función f del punto previo retorne, ¿Cuál es el contenido de los
registros $t5, $s3, $ra y $sp?. Tener en mente que se conoce lo que hace la función f,
pero de la función func sólo se conoce su declaración.
Ejercicio 20 Sean:
a.
FACT:
L1:
b.
FACT:
L1:
sw
sw
addi
slti
beq
addi
addi
jr
addi
jal
addi
lw
lw
mul
jr
addi
sw
sw
add
slti
beq
mul
addi
jr
addi
jal
addi
lw
lw
addi
jr
$ra, 4($sp)
$a0, 0($sp)
$sp, $sp, -8
$t0, $a0, 1
$t0, $0, L1
$v0, $0, 1
$sp, $sp, 8
$ra
$a0, $a0, -1
FACT
$sp, $sp, 8
$a0, 0($sp)
$ra, 4($sp)
$v0, $a0, $v0
$ra
$sp, $sp, 8
$ra, 4($sp)
$a0, 0($sp)
$s0, $0, $a0
$t0, $a0, 2
$t0, $0, L1
$v0, $s0, $v0
$sp, $sp, -8
$ra
$a0, $a0, -1
FACT
$v0, $0, 1
$a0, 0($sp)
$ra, 4($sp)
$sp, $sp, -8
$ra
i) Los programas (en assembler MIPS) de la tabla computan el factorial de un número
dado. Dicho número es ingresado a través del registro $a0, y el resultado es devuelto a
través del registro $v0. En ambos códigos hay errores. Corregirlos.
ii) Asumir que para ambos programas recursivos, el valor de entrada es 4. Rescribir dichos
programas para que funcionen de manera no recursiva. Restringir el uso de registros
sólo a $s0-$s7. ¿Cuántas instrucciones se ejecutan en la versión recursiva? ¿Y en la no
recursiva?
iii) Mostrar el contenido del stack después de cada llamada a función, asumiendo que el
valor de entrada es 4.
13
Sean:
a.
FIB:
L1:
EXIT:
b.
FIB:
L1:
EXIT:
addi
sw
sw
sw
slti
beq
addi
j
addi
jal
addi
addi
jal
add
lw
lw
lw
addi
jr
addi
sw
sw
sw
slti
beq
addi
j
addi
jal
addi
jal
add
lw
lw
lw
addi
jr
$sp,
$ra,
$s1,
$a0,
$t0,
$t0,
$v0,
EXIT
$a0,
FIB
$s1,
$a0,
FIB
$v0,
$ra,
$a0,
$s1,
$sp,
$ra
$sp,
$ra,
$s1,
$a0,
$t0,
$t0,
$v0,
EXIT
$a0,
FIB
$a0,
FIB
$v0,
$a0,
$s1,
$ra,
$sp,
$ra
$sp, -12
0($sp)
4($sp)
8($sp)
$a0, 1
$0, L1
$a0, $0
$a0, -1
$v0, $0
$a0, -1
$v0, $s1
0($sp)
8($sp)
4($sp)
$sp, 12
$sp, -12
8($sp)
4($sp)
0($sp)
$a0, 3
$0, L1
$0, 1
$a0, -1
$a0, -2
$v0, $s1
0($sp)
4($sp)
8($sp)
$sp, 12
i) Los programas (en assembler MIPS) de la tabla computan Fibonacci de un número
dado. Dicho número es ingresado a través del registro $a0, y el resultado es devuelto a
través del registro $v0. En ambos códigos hay errores. Corregirlos.
ii) Asumir que para ambos programas recursivos, el valor de entrada es 4. Rescribir dichos
programas para que funcionen de manera no recursiva. Restringir el uso de registros
sólo a $s0-$s7. ¿Cuántas instrucciones se ejecutan en la versión recursiva? ¿Y en la no
recursiva?
iii) Mostrar el contenido del stack después de cada llamada a función, asumiendo que el
valor de entrada es 4.
Ejercicio 21 Asumiendo que el stack y el segmento estático de datos se encuentran vacı́os,
y el stack y el global pointer comienzan en la dirección 0x7FFF FFFc y 0x1000 8000,
respectivamente. Además, asumiendo la convención de llamadas del Cuadro 1 del ejercicio
14
19 y que los parámetros de entrada a función son pasados a través de los registros $a0-$a3,
y que el resultado se devuelve a través de $r0 y que las funciones leaf function pueden
utilizar solamente registros guardados; dados:
a.
b.
int my global = 100;
main(){
int x = 10;
int y = 20;
int z;
z = my function(x,y);
}
int my function(int x, int y){
return x - y + my global;
}
int my global = 100;
main(){
int z;
my global+=1;
int z;
z = leaf function(my global);
}
int leaf function(int x){
return x - 1;
}
i) Transcribir los programas a assembler MIPS.
ii) Mostrar el contenido del stack y del segmento estático de datos después de cada llamada
a función.
iii) Si la función leaf function pudiera usar los registros temporales ($t0, $t1, etc.),
escribir el código MIPS para cada programa.
Dados los siguientes programas escritos en assembler MIPS que siguen la convención del Cuadro 2 del ejercicio 19:
a.
f:
b.
L:
f:
L:
add
bnez
sub
jr
add
slt
move
beqz
jr
move
jal
$v0, $a1, $a0
$a2, L
$v0, $a0, $a1
$v0
$a2, $a3, $a2
$a2, $a2, $a0
$v0, $a1
$a2, L
$ra
$a0, $a1
g
; Tail call
i) El código contiene un error y viola la convención de llamada de MIPS. ¿Cuál es el error
y cómo puede solucionarse?
ii) ¿Cuál es el código equivalente en C de este programa? Asumir que los argumento de la
función en C son denominados a, b, c, etc.
iii) Mostrar el contenido del stack después de cada llamada a función, asumiendo que el
valor de entrada es 4. En el punto que esta función es llamada, los registros $a0, $a1,
$a2 y $a3 contienen los valores 1, 100, 1000 y 30, respectivamente. ¿Qué valor retorna
la función? Si otra función g es llamada desde f, asumir que g siempre devuelve 500.
15
Ejercicio 22 Dadas las siguientes cadenas de caracteres:
a.
b.
hello world
0123456789
i) Transcribirlos a los valores en bytes hexadecimales ASCII .
ii) Transcribirlos a Unicode de 16-bits (usando la notación hex y el Basic Latin character
set).
Dados los siguientes valores de caracteres ASCII hexadecimales:
a.
b.
41 44 44
4D 49 50 53
i) trasladarlos a texto.
Ejercicio 23 Sean:
a.
b.
cadena de enteros decimales positivos y negativos
enteros hexadecimales positivos
i) Escribir un programa en lenguaje ensamblador MIPS que convierta una cadena de
números ASCII a un entero, bajo las condiciones que figuran en la tabla. El registro
$a0 contiene la dirección de la cadena de dı́gitos que contiene alguna combinación de 0
y 9 y que finaliza con un terminador null. El programa debe calcular el valor entero
equivalente a la cadena y almacenarlo en el registro $v0. Si en la cadena aparece un
caracter que no se corresponde con un dı́gito decimal, el programa debe terminar su
ejecución almacenando en el registro $v0 el valor -1. A modo de ejemplo, si el registro
$a0 apunta a la secuencia de tres bytes 50(10) , 52(10) y 0(10) (que corresponde a la cadena
24 con terminador null), al terminar el programa deberı́a retornar el valor 24(10) en el
registro $v0.
Ejercicio 24 Asumiendo que los registros $t1 y $t2 contienen la direcciones 0x1000 0000
y 0x1000 0010, respectivamente, y que la arquitectura MIPS utiliza el modo de direccionamiento big-endian. Sean:
a.
b.
lbu
sw
lb
sh
$t0,
$t0,
$t0,
$t0,
0($t1)
0($t2)
0($t1)
0($t2)
i) Asumiendo que el dato en la dirección de memoria 0x1000 0000 es:
1000 0000
12
34
56
78
¿Qué valor es almacenado en la dirección apuntada por el registro $t2? Asumir que la
dirección de memoria apuntada a $t2 es inicializada en 0xFFFF FFFF
ii) Asumiendo que el dato en la dirección de memoria 0x1000 0000 es:
1000 0000
80
80
80
80
¿Qué valor es almacenado en la dirección apuntada por el registro $t2? Asumir que la
dirección de memoria apuntada a $t2 es inicializada en 0x0000 0000
16
iii) Asumiendo que el dato en la dirección de memoria 0x1000 0000 es:
1000 0000
11
00
00
FF
¿Qué valor es almacenado en la dirección apuntada por el registro $t2? Asumir que la
dirección de memoria apuntada a $t2 es inicializada en 0x5555 5555
Ejercicio 25 Dados:
a.
a.
0010 0000 0000 0001 0100 1001 0010 0100(2)
0000 1111 1011 1110 0100 0000 0000 0000(2)
i) Escribir un programa en assembler MIPS que cree las constantes de 32-bits de la tabla
y que almacene dicho valor en el registro $t1.
ii) Si el valor actual del PC=0x00000000, ¿Es posible utilizar una sola instrucción jump
para obtener un PC con el valor de la tabla?
iii) Si el valor actual del PC=0x00000600, ¿Es posible utilizar una sola instrucción branch
para obtener un PC con el valor de la tabla?
iv) Si el valor actual del PC=0x1FFFF000, ¿Es posible utilizar una sola instrucción branch
para obtener un PC con el valor de la tabla?
v) Si el campo inmediato de una instrucción MIPS fuera de solo 8-bits de ancho, escribir
un código MIPS que cree las constantes de 32-bits de la tabla y almacene sus valores en
el registro $t1. No está permitido utilizar la instrucción lui.
Dados:
a.
b.
lui
addi
lui
andi
$t0,
$t0,
$t0,
$t0,
0x1234
$t0, 0x5678
0x1234
$t0, 0x5678
i) ¿Cuál es el valor del registro $t0 luego de ejecutar el código de la tabla?
ii) Escribir un código C equivalente al código assembler de la tabla. Asumir que la constante
más grande que se puede cargar en un entero de 32-bits son 16-bits.
Ejercicio 26 Dados:
a.
a.
0002 0000(16)
FFFF FF00(16)
i) Si el PC=0x0000 0000, ¿Cuántas instrucciones branch (no jump) son necesarias para
alcanzar la dirección de la tabla?
ii) Si el PC=0x0000 0000, ¿Cuántas instrucciones jump (no branch, ni jump a registro) son
necesarias para alcanzar la dirección de la tabla?
iii) Para reducir el tamaño de un programa MIPS, los diseñadores de MIPS han decidido
recortar el campo inmediato de las instrucciones de tipo I-type de 16-bits a 8-bits. Si
el PC=0x0000 0000, ¿Cuántas instrucciones branch son necesarias para setear al PC la
dirección de la tabla?
Dados:
a.
b.
128 registros
4 veces más operaciones diferentes
17
i) Si el set de instrucciones del procesador MIPS es modificado, el formato de instrucción
también deberá ser modificado. Para cada cambio sugerido en la tabla, ¿Cuál es el
impacto sobre el rango de direcciones para una instrucción beq? Asumir que todas las
instrucciones se mantienen en un largo de 32-bits y cada cambio realizado al formato de
instrucción de las instrucciones de tipo I-type sólo incrementa/decrementa el campo
inmediato de la instrucción beq.
ii) Si el set de instrucciones del procesador MIPS es modificado, el formato de instrucción
también deberá ser modificado. Para cada cambio sugerido en la tabla, ¿Cuál es el
impacto sobre el rango de direcciones para una instrucción jump? Asumir que todas las
instrucciones se mantienen en un largo de 32-bits y cada cambio realizado al formato de
instrucción de las instrucciones de tipo J-type sólo impacta en el campo de dirección
de la instrucción jump.
iii) Si el set de instrucciones del procesador MIPS es modificado, el formato de instrucción
también deberá ser modificado. Para cada cambio sugerido en la tabla, ¿Cuál es el
impacto sobre el rango de direcciones para una instrucción jump de registro? Asumir
que todas las instrucciones se mantienen en un largo de 32-bits.
Ejercicio 27 Sean:
a. Direccionamiento base o desplazamiento
a. Direccionamiento pseudo-directo
i) Dado los modos de direccionamiento de MIPS, que se encuentran en la tabla anterior,
dar un ejemplo de una instrucción MIPS que muestre dicho modo de direccionamiento.
ii) Para la instrucción del punto anterior, ¿Cuál es el tipo de instrucción utilizada (I-type,
etc.)?
iii) Listar las ventajas y desventajas de cada modo de direccionamiento. Escribir un código
MIPS que muestre dichas ventajas y desventajas.
Sean:
a.
b.
0x00400000
...
0x00403100
0x00000100
...
0x04000010
beq
$s0, $0, FAR
FAR:
addi
j
$s0, $s0, 1
AWAY
AWAY:
addi
$s0, $s0, 1
i) Para las sentencias MIPS de la tabla, mostrar su repesentación a nivel bit en hexadecimal
de cada una.
ii) Al reducir el tamaño del campo inmediato de las instrucciones de tipo I-type y J-type,
se pueden ahorrar los bits necesarios para representar este tipo de instrucciones. Si
el campo inmediato de las instrucciones I-type fuera de 8-bits y el de las J-type
fuera de 18-bits, rescribir el código MIPS de la tabla para que refleje dicho cambio. No
está permitido utilizar la instrucción lui.
iii) ¿Cuántas instrucciones de más se necesitan para ejecutar el código del punto anterior,
comparado con el de la tabla?
18
MIPS Reference Data Card (“Green Card”) 1. Pull along perforation to separate card 2. Fold bottom side (columns 3 and 4) together
M I P S Reference Data
CORE INSTRUCTION SET
FORNAME, MNEMONIC MAT
OPERATION (in Verilog)
add
Add
R R[rd] = R[rs] + R[rt]
Add Immediate
addi
Add Imm. Unsigned addiu
R[rt] = R[rs] + SignExtImm
(1,2)
I
R[rt] = R[rs] + SignExtImm
(2)
addu
R R[rd] = R[rs] + R[rt]
And
and
R R[rd] = R[rs] & R[rt]
And Immediate
andi
I
Branch On Equal
beq
I
Branch On Not Equal bne
I
j
J
Jump And Link
jal
J
R[31]=PC+8;PC=JumpAddr
Jump Register
jr
ll
R PC=R[rs]
R[rt]={24’b0,M[R[rs]
I
+SignExtImm](7:0)}
R[rt]={16’b0,M[R[rs]
I
+SignExtImm](15:0)}
I R[rt] = M[R[rs]+SignExtImm]
Load Upper Imm.
lui
I
R[rt] = {imm, 16’b0}
Load Word
lw
I
R[rt] = M[R[rs]+SignExtImm]
Nor
nor
R R[rd] = ~ (R[rs] | R[rt])
Or
or
R R[rd] = R[rs] | R[rt]
Or Immediate
ori
I
Set Less Than
slt
R R[rd] = (R[rs] < R[rt]) ? 1 : 0
Set Less Than Imm. slti
Set Less Than Imm.
sltiu
Unsigned
Set Less Than Unsig. sltu
9hex
0 / 24hex
Jump
lhu
8hex
0 / 21hex
R[rt] = R[rs] & ZeroExtImm
if(R[rs]==R[rt])
PC=PC+4+BranchAddr
if(R[rs]!=R[rt])
PC=PC+4+BranchAddr
PC=JumpAddr
Load Halfword
Unsigned
Load Linked
OPCODE
/ FUNCT
(Hex)
(1) 0 / 20hex
I
Add Unsigned
Load Byte Unsigned lbu
ARITHMETIC CORE INSTRUCTION SET
1
(3)
chex
(4)
4hex
(4)
(5)
(5)
5hex
2hex
3hex
0 / 08hex
(2)
(2)
(2,7)
24hex
25hex
30hex
fhex
(2)
23hex
0 / 27hex
0 / 25hex
R[rt] = R[rs] | ZeroExtImm
(3)
dhex
0 / 2ahex
FLOATING-POINT INSTRUCTION FORMATS
R[rt] = (R[rs] < SignExtImm)? 1 : 0 (2) ahex
R[rt] = (R[rs] < SignExtImm)
bhex
I
?1:0
(2,6)
0
/
2bhex
R R[rd] = (R[rs] < R[rt]) ? 1 : 0
(6)
0
/
00hex
R R[rd] = R[rt] << shamt
I
Shift Left Logical
sll
Shift Right Logical
srl
Store Byte
sb
Store Conditional
sc
Store Halfword
sh
Store Word
sw
R R[rd] = R[rt] >> shamt
M[R[rs]+SignExtImm](7:0) =
I
R[rt](7:0)
M[R[rs]+SignExtImm] = R[rt];
I
R[rt] = (atomic) ? 1 : 0
M[R[rs]+SignExtImm](15:0) =
I
R[rt](15:0)
I M[R[rs]+SignExtImm] = R[rt]
Subtract
sub
R R[rd] = R[rs] - R[rt]
Subtract Unsigned
subu
28hex
(2,7)
38hex
(2)
(2)
31
31
rs
26 25
opcode
I
31
rs
26 25
opcode
J
31
rt
21 20
29hex
2bhex
(1) 0 / 22hex
0 / 23hex
rd
16 15
shamt
11 10
rt
21 20
funct
6 5
0
immediate
16 15
0
address
26 25
ft
21 20
fmt
26 25
fs
16 15
ft
21 20
fd
11 10
funct
6 5
16 15
REGISTER NAME, NUMBER, USE, CALL CONVENTION
PRESERVED ACROSS
NAME NUMBER
USE
A CALL?
$zero
0
The Constant Value 0
N.A.
$at
1
Assembler Temporary
No
Values for Function Results
$v0-$v1
2-3
No
and Expression Evaluation
$a0-$a3
4-7
Arguments
No
$t0-$t7
8-15
Temporaries
No
$s0-$s7
16-23 Saved Temporaries
Yes
$t8-$t9
24-25 Temporaries
No
$k0-$k1
26-27 Reserved for OS Kernel
No
$gp
28
Global Pointer
Yes
$sp
29
Stack Pointer
Yes
$fp
30
Frame Pointer
Yes
$ra
31
Return Address
Yes
0
Copyright 2009 by Elsevier, Inc., All rights reserved. From Patterson and Hennessy, Computer Organization and Design, 4th ed.
0
immediate
PSEUDOINSTRUCTION SET
NAME
MNEMONIC
OPERATION
blt
if(R[rs]<R[rt]) PC = Label
Branch Less Than
bgt
if(R[rs]>R[rt]) PC = Label
Branch Greater Than
ble
if(R[rs]<=R[rt]) PC = Label
Branch Less Than or Equal
bge
if(R[rs]>=R[rt]) PC = Label
Branch Greater Than or Equal
li
R[rd] = immediate
Load Immediate
move
R[rd] = R[rs]
Move
R R[rd] = R[rs] - R[rt]
(1) May cause overflow exception
(2) SignExtImm = { 16{immediate[15]}, immediate }
(3) ZeroExtImm = { 16{1b’0}, immediate }
(4) BranchAddr = { 14{immediate[15]}, immediate, 2’b0 }
(5) JumpAddr = { PC+4[31:28], address, 2’b0 }
(6) Operands considered unsigned numbers (vs. 2’s comp.)
(7) Atomic test&set pair; R[rt] = 1 if pair atomic, 0 if not atomic
opcode
31
fmt
26 25
opcode
FI
BASIC INSTRUCTION FORMATS
R
opcode
FR
0 / 02hex
(2)
OPCODE
/ FMT /FT
FOR/ FUNCT
NAME, MNEMONIC MAT
OPERATION
(Hex)
Branch On FP True bc1t FI if(FPcond)PC=PC+4+BranchAddr (4) 11/8/1/-Branch On FP False bc1f FI if(!FPcond)PC=PC+4+BranchAddr(4) 11/8/0/-div
R Lo=R[rs]/R[rt]; Hi=R[rs]%R[rt]
0/--/--/1a
Divide
divu
Divide Unsigned
R Lo=R[rs]/R[rt]; Hi=R[rs]%R[rt] (6) 0/--/--/1b
add.s FR F[fd ]= F[fs] + F[ft]
11/10/--/0
FP Add Single
FP Add
{F[fd],F[fd+1]} = {F[fs],F[fs+1]} +
add.d FR
11/11/--/0
Double
{F[ft],F[ft+1]}
11/10/--/y
FP Compare Single c.x.s* FR FPcond = (F[fs] op F[ft]) ? 1 : 0
FP Compare
FPcond = ({F[fs],F[fs+1]} op
c.x.d* FR
11/11/--/y
Double
{F[ft],F[ft+1]}) ? 1 : 0
* (x is eq, lt, or le) (op is ==, <, or <=) ( y is 32, 3c, or 3e)
FP Divide Single div.s FR F[fd] = F[fs] / F[ft]
11/10/--/3
FP Divide
{F[fd],F[fd+1]} = {F[fs],F[fs+1]} /
div.d FR
11/11/--/3
Double
{F[ft],F[ft+1]}
11/10/--/2
FP Multiply Single mul.s FR F[fd] = F[fs] * F[ft]
FP Multiply
{F[fd],F[fd+1]} = {F[fs],F[fs+1]} *
mul.d FR
11/11/--/2
Double
{F[ft],F[ft+1]}
11/10/--/1
FP Subtract Single sub.s FR F[fd]=F[fs] - F[ft]
FP Subtract
{F[fd],F[fd+1]} = {F[fs],F[fs+1]} sub.d FR
11/11/--/1
Double
{F[ft],F[ft+1]}
lwc1
I F[rt]=M[R[rs]+SignExtImm]
Load FP Single
(2) 31/--/--/-Load FP
F[rt]=M[R[rs]+SignExtImm];
(2)
ldc1
I
35/--/--/-Double
F[rt+1]=M[R[rs]+SignExtImm+4]
mfhi
R R[rd] = Hi
0 /--/--/10
Move From Hi
mflo
R R[rd] = Lo
0 /--/--/12
Move From Lo
10 /0/--/0
Move From Control mfc0 R R[rd] = CR[rs]
mult
R {Hi,Lo} = R[rs] * R[rt]
0/--/--/18
Multiply
Multiply Unsigned multu R {Hi,Lo} = R[rs] * R[rt]
(6) 0/--/--/19
sra
R R[rd] = R[rt] >>> shamt
0/--/--/3
Shift Right Arith.
swc1
I M[R[rs]+SignExtImm] = F[rt]
Store FP Single
(2) 39/--/--/-Store FP
M[R[rs]+SignExtImm] = F[rt];
(2)
sdc1
I
3d/--/--/-Double
M[R[rs]+SignExtImm+4] = F[rt+1]
2
0
IEEE 754 FLOATING-POINT
STANDARD
4
IEEE 754 Symbols
Exponent
Fraction
Object
0
0
±0
0
≠0
± Denorm
1 to MAX - 1 anything ± Fl. Pt. Num.
±∞
MAX
0
MAX
≠0
NaN
S.P. MAX = 255, D.P. MAX = 2047
(-1)S × (1 + Fraction) × 2(Exponent - Bias)
where Single Precision Bias = 127,
Double Precision Bias = 1023.
IEEE Single Precision and
Double Precision Formats:
S
31
Exponent
23 22
S
63
Fraction
30
0
Exponent
62
Fraction
52 51
0
MEMORY ALLOCATION
$sp
7fff fffchex
$gp
1000 8000hex
STACK FRAME
...
Argument 6
Argument 5
$fp
Saved Registers
Stack
Stack
Grows
Dynamic Data
Static Data
Local Variables
1000 0000hex
pc
Higher
Memory
Addresses
$sp
Text
0040 0000hex
Lower
Memory
Addresses
Reserved
0hex
DATA ALIGNMENT
Double Word
Word
Word
Halfword
Halfword
Halfword
Halfword
Byte Byte Byte Byte Byte Byte
Byte
Byte
0
1
2
3
4
5
6
7
Value of three least significant bits of byte address (Big Endian)
EXCEPTION CONTROL REGISTERS: CAUSE AND STATUS
B
Interrupt
Exception
D
Mask
Code
31
15
8
Pending
Interrupt
15
8
6
2
U
M
E I
L E
4
1
0
BD = Branch Delay, UM = User Mode, EL = Exception Level, IE =Interrupt Enable
EXCEPTION CODES
Number Name
Cause of Exception
Number Name Cause of Exception
0
Int
Interrupt (hardware)
9
Bp
Breakpoint Exception
Address Error Exception
Reserved Instruction
4
AdEL
10
RI
(load or instruction fetch)
Exception
Address Error Exception
Coprocessor
5
AdES
11
CpU
(store)
Unimplemented
Bus Error on
Arithmetic Overflow
6
IBE
12
Ov
Instruction Fetch
Exception
Bus Error on
7
DBE
13
Tr
Trap
Load or Store
8
Sys
Syscall Exception
15
FPE Floating Point Exception
SIZE PREFIXES (10x for Disk, Communication; 2x for Memory)
PREPREPREPRESIZE
FIX
SIZE
FIX
SIZE FIX SIZE FIX
10-3 milli- 10-15 femto103, 210 Kilo- 1015, 250 Peta6 20
18 60
Mega- 10 , 2
Exa10-6 micro- 10-18 atto10 , 2
9 30
21 70
10 , 2
Giga- 10 , 2
Zetta- 10-9 nano- 10-21 zepto1012, 240 Tera- 1024, 280 Yotta- 10-12 pico- 10-24 yoctoThe symbol for each prefix is just its first letter, except µ is used for micro.
Copyright 2009 by Elsevier, Inc., All rights reserved. From Patterson and Hennessy, Computer Organization and Design, 4th ed.
MIPS Reference Data Card (“Green Card”) 1. Pull along perforation to separate card 2. Fold bottom side (columns 3 and 4) together
3
OPCODES, BASE CONVERSION, ASCII SYMBOLS
MIPS (1) MIPS (2) MIPS
Hexa- ASCII
Hexa- ASCII
DeciDeciopcode funct
funct
Binary
deci- Chardeci- Charmal
mal
(31:26)
(5:0)
(5:0)
mal acter
mal acter
sll
00 0000
0
0 NUL
64
40
@
add.f
(1)
sub.f
00 0001
1
1 SOH
65
41
A
j
srl
mul.f
00 0010
2
2 STX
66
42
B
jal
sra
div.f
00 0011
3
3 ETX
67
43
C
beq
sllv
sqrt.f
00 0100
4
4 EOT
68
44
D
bne
abs.f
00 0101
5
5 ENQ
69
45
E
blez
srlv
mov.f
00 0110
6
6 ACK
70
46
F
bgtz
srav
neg.f
00 0111
7
7 BEL
71
47
G
addi
jr
00 1000
8
8 BS
72
48
H
addiu jalr
00 1001
9
9 HT
73
49
I
slti
movz
00 1010 10
a LF
74
4a
J
sltiu movn
00 1011 11
b VT
75
4b
K
andi
syscall round.w.f 00 1100
12
c FF
76
4c
L
ori
break
trunc.w.f 00 1101
13
d CR
77
4d
M
xori
ceil.w.f 00 1110
14
e SO
78
4e
N
lui
sync
floor.w.f 00 1111
15
f SI
79
4f
O
mfhi
01 0000 16
10 DLE
80
50
P
mthi
(2)
01 0001 17
11 DC1
81
51
Q
mflo
movz.f
01 0010 18
12 DC2
82
52
R
mtlo
movn.f
01 0011 19
13 DC3
83
53
S
01 0100 20
14 DC4
84
54
T
01 0101 21
15 NAK
85
55
U
01 0110 22
16 SYN
86
56
V
01 0111 23
17 ETB
87
57
W
mult
01 1000 24
18 CAN
88
58
X
multu
01 1001 25
19 EM
89
59
Y
div
01 1010 26
1a SUB
90
5a
Z
divu
01 1011 27
1b ESC
91
5b
[
01 1100 28
1c FS
92
5c
\
01 1101 29
1d GS
93
5d
]
01 1110 30
1e RS
94
5e
^
01 1111 31
1f US
95
5f
_
lb
add
cvt.s.f
10 0000 32
20 Space 96
60
‘
lh
addu
cvt.d.f
10 0001 33
21
!
97
61
a
lwl
sub
10 0010 34
22
"
98
62
b
lw
subu
10 0011 35
23
#
99
63
c
lbu
and
cvt.w.f
10 0100 36
24
$
100
64
d
lhu
or
10 0101 37
25 %
101
65
e
lwr
xor
10 0110 38
26
&
102
66
f
nor
10 0111 39
27
’
103
67
g
sb
10 1000 40
28
(
104
68
h
sh
10 1001 41
29
)
105
69
i
swl
slt
10 1010 42
2a
*
106
6a
j
sw
sltu
10 1011 43
2b
+
107
6b
k
10 1100 44
2c
,
108
6c
l
10 1101 45
2d
109
6d
m
swr
10 1110 46
2e
.
110
6e
n
cache
10 1111 47
2f
/
111
6f
o
ll
tge
c.f.f
11 0000 48
30
0
112
70
p
lwc1
tgeu
c.un.f
11 0001 49
31
1
113
71
q
lwc2
tlt
c.eq.f
11 0010 50
32
2
114
72
r
pref
tltu
c.ueq.f
11 0011 51
33
3
115
73
s
teq
c.olt.f
11 0100 52
34
4
116
74
t
ldc1
c.ult.f
11 0101 53
35
5
117
75
u
ldc2
tne
11 0110 54
36
6
118
76
v
c.ole.f
c.ule.f
11 0111 55
37
7
119
77
w
sc
11 1000 56
38
8
120
78
x
c.sf.f
swc1
57
39
9
121
79
y
c.ngle.f 11 1001
swc2
11 1010 58
3a
:
122
7a
z
c.seq.f
c.ngl.f
11 1011 59
3b
;
123
7b
{
c.lt.f
11 1100 60
3c
<
124
7c
|
sdc1
11 1101 61
3d
=
125
7d
}
c.nge.f
sdc2
11 1110 62
3e
>
126
7e
~
c.le.f
c.ngt.f
11 1111 63
3f
?
127
7f DEL
(1) opcode(31:26) == 0
(2) opcode(31:26) == 17ten (11hex); if fmt(25:21)==16ten (10hex) f = s (single);
if fmt(25:21)==17ten (11hex) f = d (double)