You are on page 1of 36

Introducción 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 diseño de CPUs donde cada instrucción tiene una sola función y se ejecuta de manera rápida.  Es lo contrario de CISC (Complex Instruction Set Architecture), donde cada instrucción hace muchas funciones.

Universidad de Sonora

Arquitectura de Computadoras

2

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 Sonora

Arquitectura de Computadoras

3

Solo hay 3 formatos de instrucción. Hennessy en Stanford University.MIPS  El primer MIPS fue desarrollado en 1981 por John L. etc.  Principio de regularidad. Universidad de Sonora Arquitectura de Computadoras 4 . Instrucciones sencillas.  Principio de simplicidad. dispositivos Windows CE.  Usados. gateways. entre otros. en algunas consolas de videojuego de Nintendo y Sony y sistemas empotrados como ruteadores Cisco. Todas las instrucciones ocupan 4 bytes (32 bits).

Aritmética MIPS  Todas las instrucciones aritméticas tienen 3 operandos  El orden de los operandos es fija (primero el operando destino) Ejemplo: C: MIPS: A=B+C add $s0. $s2 (las variables son asociadas por el compilador) Universidad de Sonora Arquitectura de Computadoras 5 . $s1.

$s2 add $s0.Aritmética MIPS  La simplicidad favorece la regularidad. E = F .A. $s1. C: A = B + C + D. $t0. Universidad de Sonora Arquitectura de Computadoras 6 MIPS: . $s5. $s3 sub $s4. add $t0. $s0  Los operandos de las instrucciones aritméticas deben ser registros.

Universidad de Sonora Arquitectura de Computadoras 7 .  Se usan para guardar valores temporales y resultados de operaciones aritméticas.  Tienen poca capacidad. 4 bytes (32 bits) en MIPS.¿Registros?  Un registro es una memoria integrada en la CPU. pero de acceso muy rápido.

 Solo hay 32 registros disponibles en MIPS.Registros vs.  El compilador asocia las variables con los registros. Universidad de Sonora Arquitectura de Computadoras 8 . Memoria  Los operandos de las instrucciones aritméticas deben ser registros.  ¿Y los programas con muchas variables?  Las variables se guardan en la memoria principal.

Registros vs.  A esto se le conoce como arquitectura load/store. Universidad de Sonora Arquitectura de Computadoras 9 . Memoria  La mayoría de las CPUs modernas mueven las variables de la memoria principal a los registros. operan sobre ellos y regresan el resultado a la memoria.  MIPS emplea arquitectura load/store.

el índice apunta a un byte de memoria. 0 1 2 3 4 5 .Organización de la memoria  MIPS usa byte addressing. 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 Sonora Arquitectura de Computadoras 10 ...

 Los registros son de 4 bytes (32 bits).  La memoria está alineada.. Datos 32 bits Datos 32 bits Datos 32 bits Datos 32 bits Universidad de Sonora Arquitectura de Computadoras 11 .Organización de la memoria  Las palabras son de 4 bytes (32 bits). Las palabras deben comenzar en direcciones que son múltiplo de 4. 0 4 8 12 ..

Organización de la memoria  MIPS se puede configurar por hardware como big- endian o little–endian.  230 palabras con dirección desde 0 hasta 232 – 4.  La memoria tiene:  232 bytes con dirección desde 0 hasta 232 – 1.  ¿Qué significan los 2 bits menos significativos de una dirección de palabra? Universidad de Sonora Arquitectura de Computadoras 12 .  Se usan 32 bits para direccionar la memoria.

sw – el destino va segundo. MIPS: lw $t0. t0 = Memoria[s3 + 32] . $t0 sw $t0. 13 Arquitectura de Computadoras . t0 = s2 + t0 .Instrucciones de referencia a memoria  Instrucciones lw (load word) y sw (store word). Memoria[s3 + 32] = t0 s2 valor de h s3 dirección A[0] t0 valor de A[8] Universidad de Sonora Ojo: lw – el destino va primero. $s2. C: A[8] = h + A[8]. 32($s3) add $t0. 32($s3) .

Memoria[$s3 + 32] = $t0  32 es el offset.  El registro base es $s3. Universidad de Sonora Arquitectura de Computadoras 14 . 32($s3) .  Por ejemplo: lw $t0. a la constante se le llama offset y al registro que se suma para obtener la dirección se le llama registro base.Operandos de memoria  En las instrucciones de memoria. 32($s3) . $to = Memoria[$s3 + 32] sw $t0.

En resumen:  MIPS  Carga palabras pero direcciona bytes. $s3 sub $s1.  Instrucción Significado $s1 = $s2 + $s3 $s1 = $s2 – $s3 $s1 = Memoria[$s2+100] Memoria[$s2+100] = $s1 add $s1. $s2.  Puede ser big-endian o little-endian. $s2.  Aritmética usa solamente registros. $s3 lw $s1. 100($s2) Universidad de Sonora Arquitectura de Computadoras 15 . 100($s2) sw $s1.

4($2) jr $31 Universidad de Sonora Arquitectura de Computadoras 16 . int k) { int temp. 4($2) sw $16.El primer ejemplo swap(int v[]. 4 add $2. 0($2) sw $15. 0($2) lw $16. $4. $5. swap: muli $2. } v[k+1] = temp. temp = v[k] v[k] = v[k+1]. $2 lw $15.

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

$16 tiene el valor de v[k+1] // 5 . $2 = $5 * 4. } Universidad de Sonora Arquitectura de Computadoras 18 // inicializa // 1 .$16 se guarda en v[k] // 6 .El primer ejemplo  Ahora en seudo-C con apuntadores swap (int v[].$15 se guarda en v[k+1] . $2 = $4 + $2 $15 = *($2 + 0) $16 = *($2 + 4) *($2 + 0) = $16. int k) { $4 = &v[0].&v[0]) // 2 . $5 = k.$15 tiene el valor de v[k] // 4 . *($2 + 4) = $15.$2 es (&v[k] .$2 apunta a v[k] // 3 .

int t2 = v[k + 1]. int k) { int t1 = v[k]. v[k + 1] = t1. v[k] = t2. } Universidad de Sonora Arquitectura de Computadoras 19 .El primer ejemplo  Y ahora en C normal: swap (int v[].

 El ensamblador traduce cada instrucción de lenguaje ensamblador a lenguaje de máquina. la instrucción add $t0.  El hardware solo entiende bits. $s1.  Por ejemplo.Lenguaje de máquina  El lenguaje de máquina es lenguaje binario. $s2 se traduce a 00000010001100100100100000100000 Universidad de Sonora Arquitectura de Computadoras 20 .

 01001 es el número del registro $t0.  10010 es el número del registro $s2.Lenguaje de máquina 00000010001100100100100000100000 se descompone en:  000000 es el opcode del add.  10001 es el número del registro $s1.  100000 es el código de la suma de registros.  00000 son bits de relleno (don’t care). Universidad de Sonora Arquitectura de Computadoras 21 .

la instrucción add destino. 5. 000000 es el código del add. 6. fuente1.Lenguaje de máquina En general. 3. 2. Universidad de Sonora Arquitectura de Computadoras 22 . 4. fuente2 genera el código máquina 000000fffffgggggdddddxxxxx100000 donde 1. fffff es el número del registro fuente 1 ggggg es el número del registro fuente 2 ddddd es el número del registro destino xxxxx son don’t care 100000 es el código de la suma de registros.

Universidad de Sonora Arquitectura de Computadoras 23 .  Formato J. La instrucción es un brinco (jump).Formatos de instrucción Hay 3 formatos de instrucción:  Formato R.  Formato I. Todos los operandos son registros. Hay un operando inmediato (número).

$t0 = $s1 + $s2 .Formatos de instrucción Ejemplos:  Formato R. C  Formato J. add $t0. $s1. addi $t0. brinca a C [dirección de 16 bits] Universidad de Sonora Arquitectura de Computadoras 24 . $t0 = $s1 + C [número de 16 bits] . jC . $s2  Formato I. $s1.

Universidad de Sonora Arquitectura de Computadoras 25 . cambian la siguiente instrucción que será ejecutada.  Alteran el flujo de control.  En otras palabras.Instrucciones de control  Instrucciones de toma de decisión.

$t.Instrucciones de control En MIPS hay dos instrucciones de brinco condicional: 1. $t. C Universidad de Sonora Arquitectura de Computadoras 26 . . beq $s. 2. brinca a la dirección C si $s == $t. bne $s. C . brinca a la dirección C si $s != $t.

$t0: valor de h MIPS: L1: Universidad de Sonora Arquitectura de Computadoras 27 . $t2: valor de j . $t2 … .Instrucciones de control Ejemplo: C: if (i == j) h = i + j. L1 add $t0. $t1: valor de i. $t2. bne $t1. $t1.

se regresa con jr $31 Arquitectura de Computadoras 28 2. brinca a la dirección guardada en $r . llama al procedimiento que comienza en C .Instrucciones de control En MIPS hay tres instrucciones de brinco incondicional: 1. jC . la dirección de regreso se guarda en $31 . jr $r 3. jal C Universidad de Sonora . brinca a la dirección C . es decir.

$s1.Instrucciones de control Ejemplo: C: if (i != j) h = i + j. else h = i – j. bne $s1. $s0 = h j L2 . $s1 = i. $s0 = h … Arquitectura de Computadoras 29 MIPS: L1: L2: Universidad de Sonora . $s2. $s1. $s2 . L1 . $s2 . brinca al final add $s0. $s2 = j sub $s0.

regreso en el registro 31 . regresa al programa principal 30 Arquitectura de Computadoras . … void foo () { … } MIPS: foo: Universidad de Sonora jal foo … … jr $31 .Instrucciones de control Ejemplo: C foo (). brinca a foo. guarda la dirección de .

$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. Universidad de Sonora Arquitectura de Computadoras 31 . ¿Y si la condición es if (i < j)?  Existe la instrucción slt (set if less than): slt $t0.  slt se usa junto con beq o bne para condiciones if (i < j).Instrucciones de control  MIPS tiene beq (brinca si es igual) y bne (brinca si no es igual).

j 32 . $zero siempre vale 0 . $s2 … Arquitectura de Computadoras L1: L2: Universidad de Sonora .Instrucciones de control Ejemplo: C: if (i < j) h = i + j. brinca al final . $s2 beq $s3. else h = i – j. $zero. $s1. $s2 j L2 sub $s0. then h = i + j . $s2 = j $s3 = i < j . $s1. $s1. $s1 = i. L1 add $s0. else h = i . MIPS: slt $s3.

$zero siempre vale 0 . $s1. brinca al final .$s2 33 . checa su $s1 < $s2 . L3 slt $s3. $s1. $zero. else $s0 = $s1 . $s2 j L2 sub $s0.Instrucciones de control Ejemplo: C: if (i <= j) h = i + j. $s1. brinca si $s1 == $s2 . $s2. beq $s1. $s2 … Arquitectura de Computadoras MIPS: L3: L1: L2: Universidad de Sonora . L1 add $s0. $s2 beq $s3. then $s0 = $s1 + $s2 . else h = i – j.

L beq $s4. es L Llama al procedimiento L Arquitectura de Computadoras 34 .100($s2) bne $s4. instr.Resumen Instrucción add $s1.$s3 lw $s1.$s5.$s2. es L si $s4 != $s5 Sig.$s2. es L si $s4 = $s5 Sig.$s3 sub $s1.$s5. instr.L jL jal L Universidad de Sonora Significado $s1 = $s2 + $s3 $s1 = $s2 – $s3 $s1 = Memoria[$s2+100] Memoria[$s2+100] = $s1 Sig. instr.100($s2) sw $s1.

tienen una constante en su tercer operando. $29. $29. 4 . 0xFF . 6 . $29 = $29 | 0xFF Universidad de Sonora Arquitectura de Computadoras 35 .  Por ejemplo: addi $29. $29 = $29 + 4 slti $8. 10 . $8 = $18 < 10 andi $29. $18.  Las constantes están limitadas a 16 bits con signo. $29. $29 = $29 & 6 ori $29.Constantes  Las instrucciones con formato I (inmediato).

C ori $x. 2. guarda C en los 16 bits menos . C Arquitectura de Computadoras 36 Universidad de Sonora . $zero. como se verá después): 1.Constantes  Se pueden tener constantes de 32 bits. lui $x. significativos del registro $x . pero solo si se almacenan en un registro. significativos del registro $x  En lugar de ori se puede usar: addi $x. C .  Se necesitan dos instrucciones (o una seudo instrucción. guarda C en los 16 bits mas .