En esta página hay una documentación guai a lo referente a las instrucciones MIPS.

Se programa en MIPS. Algunas cosas que me llaman la atención/son importantes:

• El compilador maximiza el uso de registros
• Una dirección por byte, direcciones múltipo de 4
• Lenguaje Big Endian, el byte más significativo en la dirección más baja.
• Registros de propósito general se identifican con $s0, $s1,… para variables, y $t0, $t1,… para valores temporales.
• Números negativos en complemento a 2 (cambiar 0’s por 1’s y sumar 1)
• Registros específicos de floats $f0, $f1, ...

Los tipos de datos serán los siguientes

• Byte -> 8 bits
• Halfword -> 16 bits
• Word -> 32 bits
• Long -> 64 bits

Operandos en registros

add $t0, $s1, $s2     # $t0 <- s1 + s2
add $t0, $s1, $zero   # $t0 <- s1
sub $s0, $t0, $t1     # $s0 <- t0 - t1

Para operaciones sin signo se utiliza addu y subu

Para operaciones con precisión simple se utiliza adds y subs

Para operaciones con precisión doble se utiliza addd y subd

Instrucciones de acceso a memoria

• Leer (load word): lw $t0,8($s3) # $t0 <- [$s3]+8
• Escribir(store word): sw $t0,8($s3) # [$s3]+8 <- $t0

Operandos byte y halfword en memoria

Siendo rs y rt números de primer y segundo registro fuente

• Leer extendiendo el signo hasta 32 bits en rt:

lb rt, offset(rs)    # Byte
lh rt, offset(rs)    # Halfword

• Leer extendiendo con 0’s hasta 32 bits en rt

lbu rt, offset(rs)   # Byte
lhu rt, offset(rs)   # Halfword

• Escribir los bits menos significativos de rt

sb rt, offset(rs)    # Byte
sh rt, offset(rs)    # Halfword

Multiplicación y división entera

Primero se hace la multiplicación, y el resultado te lo deja en HI y LO. Primero mult y luego mfhi.

• Registros HI y LO para poner el resultado

mfhi rd       # rd <- HI
mflo rd       # rd <- LO

• Multiplicación. Siendo HI los 32 bits más significativos y LO los 32 bits menos significativos.

mult rs, rt   # HI, LO <- rs x rt

• División

div rs, rt    # LO <- rs / rt; HI <- rs % rt

Operaciones lógicas

• Desplazamiento izquierda: sll
• Desplazamiento derecha: srl
• And lógico: and, andi
• Or lógico: or, ori
• Not lógico: nor

Formate IEEE de coma flotante

$$ x = (-1)^S \cdot (1 + \text{Fracción}) \cdot 2^{\text{Exponente-Bias}} $$

Tal que Bias es 127 en simple y 1023 en doble.

El cálculo del Bias se hace cómo \(\text{Bias} = 2^7 - 1\)

Por lo que el número más grande se calcula cómo: $$ $$ $$ \text{Bias} = 2^{\text{Exponente} - 1} - 1 \\ \text{Mantisa} = 1.1111..11 \approx 2 \Rightarrow MG = \pm 2 \cdot 2^{\text{Exponentemax-Bias}} $$

Y el número más pequeño se calcula cómo:

$$ \text{Mantisa} = 1.000.00 \approx 1 \Rightarrow MP = \pm 1 \cdot 2^{\text{Exponentemin-Bias}} $$

Suma/resta en coma flotante

1. Alinear comas decimales
2. Sumar mantisas
3. Normalizar y comprobar overflow/underflow
4. Redondear (y renormalizar)

Multiplicación en coma flotante

1. Sumar exponentes
2. Multiplicar mantisas
3. Normalizar y comprobar rango
4. Redondear (y renormalizar)
5. Obtener signo (a partir de los signos de los operandos)

Representación de instrucciones en MIPS

Representación R

Tal que:

• op: código de operación (opcode)
• rs, rt: números del primer y segundo registro fuente
• rd: número del registro destino
• shamt: cantidad de desplazamiento
• funt: código de función (amplía el opcode)

Representación I (operaciones inmediates, load/store, salto condicional)

Tal que:

• op: código de operación (opcode)
• rs: número del primer registro fuente o de dirección base
• rt: número del sgundo registro fuente o del registro destino
• const: valor entre \(-2^{15}\) y \(+2^{15}-1\)
• addr: desplazamiento a sumar a la dirección base en rs o al PC

Representación J (Salto incondicional)

Tal que:

• op: Código de operación (opcode)
• addr: Dirección a concatenar con los bits superiores del PC

Decisiones y funciones

• Instrucciones de salto condicional. Dirección destino (como la del formato I): PC + addr x 4

beq rs, rt, L1     # Saltar a etiqueta L1 si rs = rt
bne rs, rt, L1     # Saltar a etiqueta L1 si rs != rt

• Instrucción de salto incondicional. Dirección destino = Addr x 4 (como en el formato J)

j L1               # Slatar a la etiqueta L1

• Comparaciones. Se utiliza sltu y sltui para comparaciones sin signo

slt rd, rs, rt     # if (rs<rt) rd=1; else rd=0
slti rt, rs, const # if (rs < const) rt=1; else rt=0

Instrucciones para funciones

• Instrucción llamada a función jal EtiquetaFuncion que significa jump and link (saltar y volver)
• Instrucción retorno de función jr $ra que copia $ra al contador de programa.

Ejercicio típico - Escribir coma flotante en binario

Se pone la parte entera en binario 14 = 1110. Se hace de la siguiente forma:

Luego la parte decimal se pasa a binario. Y el número sería -1110,111. Se hace de la siguiente forma:

Luego se representa en coma flotante normalizada -> \( -1110,111 = -1,110111 \cdot 2^3 \) . Con lo que lo expresamos en representación IEEE con precisión simple:

S=1 F=11011100..00 (23 bits en total) E = 127 + 3 = 130 = 10000010 La representación completa es: S E F = 1 10000010 11011100..00 (32 bits)

Ejercicio típico sumar flotantes