04 MIPS - Basico

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 Sonora
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.
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 Sonora Arquitectura de Computadoras 4
Aritmtica MIPS
Todas las instrucciones aritmticas tienen 3 operandos
El orden de los operandos es fija (primero el operando
destino) Ejemplo: C: MIPS:
A=B+C add $s0, $s1, $s2
(las variables son asociadas por el compilador)

Aritmtica MIPS
La simplicidad favorece la regularidad.
C:
A = B + C + D; E = F - A;
add $t0, $s1, $s2 add $s0, $t0, $s3 sub $s4, $s5, $s0 Los operandos de las instrucciones aritmticas deben ser registros.
MIPS:
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.
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.
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.
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
10
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
11
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 232 1. 230 palabras con direccin desde 0 hasta 232 4.
Qu significan los 2 bits menos significativos de
una direccin de palabra?

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)
; t0 = Memoria[s3 + 32] ; t0 = s2 + t0 ; Memoria[s3 + 32] = t0
s2 valor de h s3 direccin A[0] t0 valor de A[8]

Ojo: lw el destino va primero. sw el destino va segundo.

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.
14
En resumen:
MIPS Carga palabras pero direcciona bytes. Puede ser big-endian o little-endian. Aritmtica usa solamente registros.
Instruccin
Significado
$s1 = $s2 + $s3 $s1 = $s2 $s3 $s1 = Memoria[$s2+100] Memoria[$s2+100] = $s1
add $s1, $s2, $s3 sub $s1, $s2, $s3 lw $s1, 100($s2) sw $s1, 100($s2)
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
16
El primer ejemplo
swap: 1 muli $2, $5, 4 2 add $2, $4, $2 3 lw $15, 0($2) 4 lw $16, 4($2) 5 sw $16, 0($2) 6 sw $15, 4($2) 7 jr $31 swap: 1 $2 = $5 * 4 ; $5 tiene el valor de k 2 $2 = $4 + $2 ; $4 apunta a v[0], $2 apunta a v[k] 3 $15 = Mem[$2+0] ; $15 tiene el valor de v[k] 4 $16 = Mem[$2+4] ; $16 tiene el valor de v[k+1] 5 Mem[$2+0] = $16 ; $16 se guarda en v[k] 6 Mem[$2+4] = $15 ; $15 se guarda en v[k+1] 7 jr $31 ; return
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; }
// inicializa
// 1 - $2 es (&v[k] - &v[0]) // 2 - $2 apunta a v[k] // 3 - $15 tiene el valor de v[k] // 4 - $16 tiene el valor de v[k+1] // 5 - $16 se guarda en v[k] // 6 - $15 se guarda en v[k+1]
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; }
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
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.
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.
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).
23
Formatos de instruccin
Ejemplos:
Formato R.
add $t0, $s1, $s2 Formato I. addi $t0, $s1, C Formato J. jC
; $t0 = $s1 + $s2 ; $t0 = $s1 + C [nmero de 16 bits]
; brinca a C [direccin de 16 bits]
24
Instrucciones de control
Instrucciones de toma de decisin.
Alteran el flujo de control. En otras palabras, cambian la siguiente instruccin
que ser ejecutada.
25
En MIPS hay dos instrucciones de brinco condicional:
1.
beq $s, $t, C
; brinca a la direccin C si $s == $t. ; brinca a la direccin C si $s != $t.
2. bne $s, $t, C
26
Ejemplo:
C: if (i == j) h = i + j; bne $t1, $t2, L1 add $t0, $t1, $t2 ; $t1: valor de i, $t2: valor de j ; $t0: valor de h
MIPS:
L1:
27
En MIPS hay tres instrucciones de brinco incondicional:
1.
jC
; brinca a la direccin C ; brinca a la direccin guardada en $r ; llama al procedimiento que comienza en C ; la direccin de regreso se guarda en $31 ; es decir, se regresa con jr $31
Arquitectura de Computadoras 28
2. jr $r 3. jal C
Ejemplo:
C: if (i != j) h = i + j; else h = i j; bne $s1, $s2, L1 ; $s1 = i, $s2 = j sub $s0, $s1, $s2 ; $s0 = h j L2 ; brinca al final add $s0, $s1, $s2 ; $s0 = h
MIPS:
L1: L2:
Ejemplo:
C foo (); void foo () { }
MIPS:
foo:
jal foo jr $31
; brinca a foo, guarda la direccin de ; regreso en el registro 31

; regresa al programa principal
30
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).
Ejemplo:
C: if (i < j) h = i + j; else
h = i j;
MIPS: slt $s3, $s1, $s2 beq $s3, $zero, L1 add $s0, $s1, $s2 j L2 sub $s0, $s1, $s2
L1: L2:
; $s1 = i, $s2 = j $s3 = i < j ; $zero siempre vale 0 ; then h = i + j ; brinca al final ; else h = i - j
32
Ejemplo: C: if (i <= j) h = i + j; else h = i j; beq $s1, $s2, L3 slt $s3, $s1, $s2 beq $s3, $zero, L1 add $s0, $s1, $s2 j L2 sub $s0, $s1, $s2
MIPS:
L3:
L1: L2:
; brinca si $s1 == $s2 ; checa su $s1 < $s2 ; $zero siempre vale 0 ; then $s0 = $s1 + $s2 ; brinca al final ; else $s0 = $s1 - $s2
33
Resumen
Instruccin
add $s1,$s2,$s3 sub $s1,$s2,$s3 lw $s1,100($s2) sw $s1,100($s2) bne $s4,$s5,L beq $s4,$s5,L jL jal L
Significado
$s1 = $s2 + $s3 $s1 = $s2 $s3 $s1 = Memoria[$s2+100] Memoria[$s2+100] = $s1 Sig. instr. es L si $s4 != $s5 Sig. instr. es L si $s4 = $s5 Sig. instr. es L Llama al procedimiento L
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
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.
2.
lui $x, C
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


04 MIPS - Basico

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

04 MIPS - Basico

Enviado por

Direitos autorais:

Formatos disponíveis

Introduccin a MIPS

MIPS, PA-RISC, PIC, PowerPC, SuperH, and SPARC.

68000 e Intel 80x86.

destino) Ejemplo: C: MIPS:

A=B+C add $s0, $s1, $s2

(las variables son asociadas por el compilador)

Registros vs. Memoria

Registros vs. Memoria

comenzar en direcciones que son mltiplo de 4.

endian o littleendian. Se usan 32 bits para direccionar la memoria. La memoria tiene:

Qu significan los 2 bits menos significativos de

una direccin de palabra?

Instrucciones de referencia a memoria

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

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

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

Ojo: lw el destino va primero. sw el destino va segundo.

add $t0, $s1, $s2 Formato I. addi $t0, $s1, C Formato J. jC

; $t0 = $s1 + $s2 ; $t0 = $s1 + C [nmero de 16 bits]

; brinca a C [direccin de 16 bits]

que ser ejecutada.

beq $s, $t, C

; brinca a la direccin C si $s == $t. ; brinca a la direccin C si $s != $t.

2. bne $s, $t, C

jal foo jr $31

; brinca a foo, guarda la direccin de ; regreso en el registro 31

En lugar de ori se puede usar: addi $x, $zero, C

Você também pode gostar