Introduccin a MIPS

MIPS
MIPS (Microprocessor without Interlocked Pipeline

Stages) es una familia de microprocesadores

RISC desarrollados por MIPS Technologies.
RISC (Reduced Instruction Set Architecture) es
una estrategia de diseo de CPUs donde cada
instruccin tiene una sola funcin y se ejecuta de
manera rpida.
Es lo contrario de CISC (Complex Instruction Set
Architecture), donde cada instruccin hace
muchas funciones.
Universidad de Sono

Arquitectura de Computadoras

RISC/CISC
Ejemplos de RISC incluyen Alpha, ARC, ARM,

AVR, MIPS, PA-RISC, PIC, PowerPC, SuperH,

and SPARC.
Ejemplos de CISC incluyen las familias

Motorola 68000 e Intel 80x86.

Universidad de Sono

Arquitectura de Computadoras

MIPS
El primer MIPS fue desarrollado en 1981 por

John L. Hennessy en Stanford University.

Principio de regularidad. Todas las
instrucciones ocupan 4 bytes (32 bits).
Principio de simplicidad. Instrucciones
sencillas. Solo hay 3 formatos de instruccin.
Usados, entre otros, en algunas consolas de
videojuego de Nintendo y Sony y sistemas
empotrados como ruteadores Cisco,
dispositivos Windows CE, gateways, etc.
Universidad de Sono

Arquitectura de Computadoras

Aritmtica MIPS
Todas las instrucciones aritmticas tienen 3

operandos
El orden de los operandos es fija (primero el
operando destino)
Ejemplo:
C: A = B + C
MIPS:
add $s0, $s1, $s2
(las variables son asociadas por el compilador)
Universidad de Sono

Arquitectura de Computadoras

Aritmtica MIPS
La simplicidad favorece la regularidad.

C: A = B + C + D;
E = F - A;
MIPS:
add $t0, $s1, $s2
add $s0, $t0, $s3
sub $s4, $s5, $s0
Los operandos de las instrucciones aritmticas
deben ser registros.
Universidad de Sono

Arquitectura de Computadoras

Registros?
Un registro es una memoria integrada en la

CPU.
Tienen poca capacidad, 4 bytes (32 bits) en
MIPS, pero de acceso muy rpido.
Se usan para guardar valores temporales y
resultados de operaciones aritmticas.

Universidad de Sono

Arquitectura de Computadoras

Registros vs. Memoria

Los operandos de las instrucciones

aritmticas deben ser registros.

Solo hay 32 registros disponibles en MIPS.
El compilador asocia las variables con los
registros.
Y los programas con muchas variables?
Las variables se guardan en la memoria

principal.
Universidad de Sono

Arquitectura de Computadoras

Registros vs. Memoria

La mayora de las CPUs modernas mueven las

variables de la memoria principal a los

registros, operan sobre ellos y regresan el
resultado a la memoria.
A esto se le conoce como arquitectura
load/store.
MIPS emplea arquitectura load/store.

Universidad de Sono

Arquitectura de Computadoras

Organizacin de la
memoria
MIPS usa byte addressing, el ndice apunta a

un byte de memoria.
0
1
2
3
4
5

8 bits of data
8 bits of data
8 bits of data
8 bits of data
8 bits of data
8 bits of data

...

Universidad de Sono

Arquitectura de Computadoras

10

Organizacin de la
memoria
Las palabras son de 4 bytes (32 bits).
Los registros son de 4 bytes (32 bits).
La memoria est alineada. Las palabras

deben comenzar en direcciones que son

mltiplo de 4.
0
4
8
12
...

Datos 32 bits
Datos 32 bits
Datos 32 bits
Datos 32 bits

Universidad de Sono

Arquitectura de Computadoras

11

Organizacin de la
memoria
MIPS se puede configurar por hardware como

big-endian o littleendian.
Se usan 32 bits para direccionar la memoria.
La memoria tiene:
232 bytes con direccin desde 0 hasta 2 32 1.
230 palabras con direccin desde 0 hasta 2 32 4.

Qu significan los 2 bits menos

significativos de una direccin de palabra?

Universidad de Sono

Arquitectura de Computadoras

12

Instrucciones de referencia
a memoria
Instrucciones lw (load word) y sw (store

word).
C:

A[8] = h + A[8];

MIPS:

lw $t0, 32($s3)
add $t0, $s2, $t0
sw $t0, 32($s3)

s2 valor de h
s3 direccin A[0]
t0 valor de A[8]
Universidad de Sono

; t0 = Memoria[s3 + 32]
; t0 = s2 + t0
; Memoria[s3 + 32] = t0

Ojo:
lw el destino va primero.
sw el destino va segundo.
Arquitectura de Computadoras

13

Operandos de memoria
En las instrucciones de memoria, a la constante

se le llama offset y al registro que se suma para

obtener la direccin se le llama registro base.
Por ejemplo:
lw $t0, 32($s3)
; $to = Memoria[$s3 + 32]
sw $t0, 32($s3)
; Memoria[$s3 + 32] = $t0
32 es el offset.
El registro base es $s3.

Universidad de Sono

Arquitectura de Computadoras

14

En resumen:
MIPS
Carga palabras pero direcciona bytes.
Puede ser big-endian o little-endian.
Aritmtica usa solamente registros.
Instruccin

Significado

add $s1, $s2, $s3

sub $s1, $s2, $s3
lw $s1, 100($s2)
sw $s1, 100($s2)

Universidad de Sono

$s1 = $s2 + $s3

$s1 = $s2 $s3
$s1 = Memoria[$s2+100]
Memoria[$s2+100] = $s1

Arquitectura de Computadoras

15

El primer ejemplo
swap(int v[], int k)
{ int temp;
temp = v[k]
v[k] = v[k+1];
}

v[k+1] = temp;

swap:
muli $2, $5, 4
add $2, $4, $2
lw $15, 0($2)
lw $16, 4($2)
sw $16, 0($2)
sw $15, 4($2)
jr $31

Universidad de Sono

Arquitectura de Computadoras

16

El primer ejemplo
swap:
swap:
1 $2 = $5 * 4 ; $5 tiene el valor de k
1 muli $2, $5, 4
2 $2 = $4 + $2 ; $4 apunta a v[0], $2
2 add $2, $4,
apunta a v[k]
$2
3 $15 = Mem[$2+0] ; $15 tiene el valor de
3 lw $15, 0($2)
v[k]
4 lw $16, 4($2)
4 $16 = Mem[$2+4] ; $16 tiene el valor de
v[k+1]
5 sw $16, 0($2)
5 Mem[$2+0] = $16 ; $16 se guarda en
6 sw $15, 4($2)
v[k]
7 jr $31
6 Mem[$2+4] = $15 ; $15 se guarda en
v[k+1]
7 jr $31 ; return

Universidad de Sono

Arquitectura de Computadoras

17

El primer ejemplo
Ahora en seudo-C con apuntadores

swap (int v[], int k)

{
$4 = &v[0];
//
$5 = k;
$2 = $5 * 4;
//
$2 = $4 + $2
//
$15 = *($2 + 0) //
$16 = *($2 + 4) //
*($2 + 0) = $16; //
*($2 + 4) = $15; //
}
Universidad de Sono

inicializa
1
2
3
4
5
6

$2 es (&v[k] - &v[0])
$2 apunta a v[k]
$15 tiene el valor de v[k]
$16 tiene el valor de v[k+1]
$16 se guarda en v[k]
$15 se guarda en v[k+1]

Arquitectura de Computadoras

18

El primer ejemplo
Y ahora en C normal:

swap (int v[], int k)

{
int t1 = v[k];
int t2 = v[k + 1];
v[k] = t2;
v[k + 1] = t1;
}
Universidad de Sono

Arquitectura de Computadoras

19

Lenguaje de mquina
El lenguaje de mquina es lenguaje binario.
El hardware solo entiende bits.
El ensamblador traduce cada instruccin de

lenguaje ensamblador a lenguaje de mquina.

Por ejemplo, la instruccin
add $t0, $s1, $s2
se traduce a
00000010001100100100100000100000

Universidad de Sono

Arquitectura de Computadoras

20

Lenguaje de mquina
00000010001100100100100000100000 se
descompone en:
000000 es el opcode del add.
10001 es el nmero del registro $s1.
10010 es el nmero del registro $s2.
01001 es el nmero del registro $t0.
00000 son bits de relleno (dont care).
100000 es el cdigo de la suma de registros.
Universidad de Sono

Arquitectura de Computadoras

21

Lenguaje de mquina
En general, la instruccin
add destino, fuente1, fuente2
genera el cdigo mquina
000000fffffgggggdddddxxxxx100000
donde
1.
2.
3.
4.
5.
6.

000000 es el cdigo del add.

fffff es el nmero del registro fuente 1
ggggg es el nmero del registro fuente 2
ddddd es el nmero del registro destino
xxxxx son dont care
100000 es el cdigo de la suma de registros.

Universidad de Sono

Arquitectura de Computadoras

22

Formatos de instruccin
Hay 3 formatos de instruccin:
Formato R. Todos los operandos son registros.
Formato I. Hay un operando inmediato

(nmero).
Formato J. La instruccin es un brinco (jump).

Universidad de Sono

Arquitectura de Computadoras

23

Formatos de instruccin
Ejemplos:
Formato R.

add $t0, $s1, $s2 ; $t0 = $s1 + $s2

Formato I.
addi $t0, $s1, C ; $t0 = $s1 + C [nmero de
16 bits]
Formato J.
jC
; brinca a C [direccin de 16
bits]
Universidad de Sono

Arquitectura de Computadoras

24

Instrucciones de control
Instrucciones de toma de decisin.
Alteran el flujo de control.
En otras palabras, cambian la siguiente

instruccin que ser ejecutada.

Universidad de Sono

Arquitectura de Computadoras

25

Instrucciones de control
En MIPS hay dos instrucciones de brinco
condicional:
1. beq $s, $t, C

; brinca a la direccin C si $s ==

$t.
2. bne $s, $t, C

; brinca a la direccin C si $s !=

$t.

Universidad de Sono

Arquitectura de Computadoras

26

Instrucciones de control
Ejemplo:
C:

if (i == j)
h = i + j;

MIPS:
bne $t1, $t2, L1
$t2: valor de j
add $t0, $t1, $t2
L1:

Universidad de Sono

Arquitectura de Computadoras

; $t1: valor de i,
; $t0: valor de h

27

Instrucciones de control
En MIPS hay tres instrucciones de brinco incondicional:
1. j C

; brinca a la direccin C

2. jr $r

; brinca a la direccin guardada en $r

3. jal C

; llama al procedimiento que comienza en C

; la direccin de regreso se guarda en $31
; es decir, se regresa con jr $31

Universidad de Sono

Arquitectura de Computadoras

28

Instrucciones de control
Ejemplo:
C:

if (i != j)
h = i + j;
else
h = i j;

MIPS:
L1:
L2:

bne $s1, $s2, L1

sub $s0, $s1, $s2
j L2
add $s0, $s1, $s2

Universidad de Sono

;
;
;
;

$s1 = i, $s2 = j
$s0 = h
brinca al final
$s0 = h

Arquitectura de Computadoras

29

Instrucciones de control
Ejemplo:
C foo ();

void foo ()
{

}
MIPS: jal foo ; brinca a foo, guarda la direccin de
; regreso en el registro 31
foo:
jr $31
; regresa al programa principal
Universidad de Sono

Arquitectura de Computadoras

30

Instrucciones de control
MIPS tiene beq (brinca si es igual) y bne (brinca

si no es igual). Y si la condicin es if (i < j)?

Existe la instruccin slt (set if less than):
slt $t0, $t1, $t2
slt es equivalente en seudo C a
$t0 = ($t1 < $t2)
$t0 vale 1 si $t1 es menor que $t2 y vale 0 en
otro caso.
slt se usa junto con beq o bne para condiciones if
(i < j).
Universidad de Sono

Arquitectura de Computadoras

31

Instrucciones de control
Ejemplo:
C:
if (i < j)
h = i + j;
else
h = i j;
MIPS:
beq
add
j L2
L1:
L2:

slt $s3, $s1, $s2

$s3, $zero, L1
$s0, $s1, $s2
; brinca al final
sub $s0, $s1, $s2

Universidad de Sono

; $s1 = i, $s2 = j $s3 = i < j

; $zero siempre vale 0
; then h = i + j
; else h = i - j

Arquitectura de Computadoras

32

Instrucciones de control
Ejemplo:
C:if (i <= j)
h = i + j;
else
h = i j;
MIPS: beq $s1, $s2, L3
; brinca si $s1 == $s2
slt $s3, $s1, $s2
; checa su $s1 < $s2
beq $s3, $zero, L1 ; $zero siempre vale 0
L3: add $s0, $s1, $s2
; then $s0 = $s1 + $s2
j L2 ; brinca al final
L1: sub $s0, $s1, $s2
; else $s0 = $s1 - $s2
L2:
Universidad de Sono

Arquitectura de Computadoras

33

Resumen
Instruccin

Significado

add $s1,$s2,$s3$s1 = $s2 + $s3

sub $s1,$s2,$s3 $s1 = $s2 $s3
lw $s1,100($s2) $s1 = Memoria[$s2+100]
sw $s1,100($s2)
Memoria[$s2+100] = $s1
bne $s4,$s5,L Sig. instr. es L si $s4 != $s5
beq $s4,$s5,L Sig. instr. es L si $s4 = $s5
jL
Sig. instr. es L
jal L Llama al procedimiento L
Universidad de Sono

Arquitectura de Computadoras

34

Constantes
Las instrucciones con formato I (inmediato),

tienen una constante en su tercer operando.

Las constantes estn limitadas a 16 bits con
signo.
Por ejemplo:
addi $29, $29, 4 ; $29 = $29 + 4
slti $8, $18, 10 ; $8 = $18 < 10
andi $29, $29, 6 ; $29 = $29 & 6
ori $29, $29, 0xFF
; $29 = $29 | 0xFF
Universidad de Sono

Arquitectura de Computadoras

35

Constantes
Se pueden tener constantes de 32 bits, pero

solo si se almacenan en un registro.

Se necesitan dos instrucciones (o una seudo
instruccin, como se ver despus):
1. lui $x, C
2. ori $x, C

;
;
;
;

guarda C en los 16 bits mas

significativos del registro $x
guarda C en los 16 bits menos
significativos del registro $x

En lugar de ori se puede usar:

addi $x, $zero, C

Universidad de Sono

Arquitectura de Computadoras

36