Download Organización MIPS.

1
Capítulo 4.
Organización MIPS.
Luego de la introducción informal del capítulo anterior, se describirán con detalle las principales
características del procesador MIPS, desde un punto de vista del programador assembler.
El siguiente es un diagrama funcional del procesador MIPS, que se estudiará en este curso.
Memoria
CPU
FPU
Registros
Alu
Registros
Mul Div
Hi
Unidad
Aritmética
L
Procesador
Traps y Manejo de Memoria
Coprocesador 0
BadVAddr
Cause
Status
EPC
Coprocesador 1
Figura 4.1. Diagrama funcional.
Se ilustra el hecho que la unidad aritmética y lógica (ALU) no está conectada a la memoria.
Sólo existe conexión entre los registros y la memoria. Dicha ALU está programada para
operaciones aritméticas enteras.
Profesor Leopoldo Silva Bijit
30-08-2008
2
Estructuras de Computadores Digitales
Se dispone además de una unidad aritmética entera especializada en las operaciones de
multiplicación y división, más adelante en el curso se estudiarán algoritmos para efectuar las
multiplicaciones como una secuencia de sumas; y las divisiones como una secuencia de restas.
Las instrucciones de multiplicación y división requieren más ciclos de reloj que una suma o
resta. Esta unidad puede describirse según una máquina secuencial, a diferencia de la unidad
para operaciones enteras, que según se verá, puede describirse en forma combinacional.
Esta unidad emplea dos registros adicionales denominados HI (por high) y LO (por Low).
Esto debido a que la multiplicación de dos cantidades de n dígitos cada una, se expresa en un
producto de 2n dígitos. La división de dos cantidades de n dígitos se expresa en un cuociente de
n dígitos y un resto de n dígitos.
También se muestra una unidad especializada, dedicada a operar con números binarios reales
(punto flotante). Se denomina FPU por Floating Point Unit.
Se muestra también un coprocesador adicional dedicado al manejo de la memoria caché y
virtual, además de atender las excepciones: Interrupciones causadas por dispositivos periféricos
que demandan atención, o para tomar decisiones en caso de una división por cero, o poder
recuperarse de un intento de direccionamiento ilegal.
A continuación algunos aspectos conceptuales relativos a la memoria.
4.1. Memoria.
Se denomina palabra (word) al contenido de una celda de la memoria. La cual puede leerse y
escribirse en una sola operación.
MIPS posee palabras de 32 bits. Las direcciones de memoria corresponden a datos de 8 bits (o
sea un byte).
Entonces hay 4 bytes en una palabra. Cuando se accesa a una palabra se leen 4 bytes
simultáneamente.
Existen dos formas de numerar los bytes contenidos en una palabra.
Big endian: (IBM, Motorola, MIPS)
Byte 0
Byte 1
Byte 2
Byte 3
Figura 4.2. Numeración big-endian.
La dirección del byte más significativo termina en 00(en binario), sólo si la palabra está
alineada.
Profesor Leopoldo Silva Bijit
30-08-2008
Organización MIPS
3
Direcciones
aumentan
hacia abajo
dirección de palabra
Byte 3
Byte 2
Byte 1
Byte 0
dirección de palabra
siguiente
Figura 4.3. Bytes en la memoria.
Little endian: (Intel, DEC)
Byte 3
Byte 2
Byte 1
Byte 0
Figura 4.4. Numeración little-endian.
La dirección del byte menos significativo termina en 00(en binario), sólo si la palabra está
alineada.
Direcciones
aumentan
hacia abajo
dirección de palabra
Byte 0
Byte 1
Byte 2
Byte 3
dirección de palabra
siguiente
Figura 4.5. Bytes en la memoria.
El ancho de la dirección define el espacio de direccionamiento. Es decir el número total de
palabras que podría tener la memoria. Éste también es el ancho del bus de dirección, que es el
conjunto de señales que lo forman. Los buses suelen describirse con notación de arreglos, por
ejemplo: ADD[31..0], es el bus de direcciones (address); y ADD2 sería una de las 32 señales.
Las instrucciones ocupan una palabra alineada. Esto implica que las direcciones de
instrucciones son múltiplos de 4.
El alineamiento requiere que un objeto comience a ser almacenado en una dirección que sea un
múltiplo de su tamaño.
Ejemplos de direcciones válidas de palabras (en hexadecimal): 0, 4, 8, C, 10, 14, 18, 1C, 20,.....
Entonces la dirección 5 no es una dirección legal de una palabra.
Direcciones alineadas de objetos que ocupen medias palabras (en hexadecimal) son: 0, 2, 4, 6, 8,
A, C, .....
Profesor Leopoldo Silva Bijit
30-08-2008
4
Estructuras de Computadores Digitales
Entonces la dirección 5 no es una dirección legal de un objeto que sea múltiplo de medias
palabras.
La definición anterior, de alineamiento, implica que el acceso a objetos (datos, que pueden ser
de cualquier largo) y a instrucciones (que en este procesador son del tamaño de una palabra de
memoria) se logre con un mínimo de accesos a memoria y con un mínimo de procesamiento.
4.2. Nombres de los Tipos de Datos.
Bit:
(Usuales en Procesadores)
0, 1
Bit String: secuencias de bits de determinado largo
4 bits
nibble
8 bits
byte
16 bits
half-word
32 bits
word
64 bits
double-word
Character:
ASCII Código de 7 bits por símbolo. Existe también el expandido que ocupa un byte.
Decimal: (BCD)
Dígitos 0-9 codificados desde 0000b hasta 1001b
Dos dígitos decimales empaquetados (en un byte)
Enteros (Integers):
Sin signo y con signo en complemento dos.
Las representaciones de números binarios con signo se tratarán más adelante.
Reales (Floating Point):
Precisión Simple. Precisión Doble.
Las representaciones de números reales en binario se tratarán más adelante.
El procesador MIPS puede mover: bytes, medias palabras y palabras, desde registro hacia la
memoria y viceversa. Puede procesar números enteros binarios de 32 bits, con y sin signo;
además tiene capacidad de procesar números binarios reales o de punto flotante en simple y
doble precisión.
Estadísticas muestran que en punto flotante el 69% de las veces, en promedio, se emplean
referencias a palabras dobles (64 bits, en este caso) y que el restante 31 % son accesos a
palabras (de 32 bits).
La frecuencia de referencias a operandos en memoria, por tamaño, en caso de enteros es: 74%
referencias a palabras; 19% a medias palabras (16 bits) y sólo en un 7% de los casos, en
promedio, se efectúan accesos a bytes.
Profesor Leopoldo Silva Bijit
30-08-2008
Organización MIPS
5
Si se desea tratar enteros largos de 64 bits, se tendrá que desarrollar funciones, en base a
operaciones enteras de 32, que son la que posee el procesador, que implementen las operaciones
que se deseen(suma, resta, almacenar, cargar, etc.)
El procesador MIPS no tiene operaciones al bit. El procesador 8051, posee un diseño especial
que le permite manipular muy eficientemente los bits, razón por la cual se lo suele denominar
procesador booleano.
4.3. Registros MIPS.
32 registros de 32 bits cada uno. Se requieren 5 bits para especificar un registro. La siguiente
tabla ilustra los nombres simbólicos y numéricos de los registros, además de una disciplina para
usarlos.
Además están los registros Hi y Lo y uno que se denomina PC(program counter), el que permite
almacenar la dirección de la instrucción que está en ejecución.
Registros MIPS y las convenciones que gobiernan su uso.
Nombre Registro Número
Uso
zero
0
Constante 0
at
1
Reservado para el assembler
v0
2
Para evaluación de expresiones y
retorno de resultados de una función
v1
3
a0
4
Argumento 1
a1
5
Argumento 2
a2
6
Argumento 3
a3
7
Argumento 4
t0
8
Temporal (no se preserva a través de los llamados)
t1
9
Temporal (no se preserva a través de los llamados)
t2
10
Temporal (no se preserva a través de los llamados)
t3
11
Temporal (no se preserva a través de los llamados)
t4
12
Temporal (no se preserva a través de los llamados)
t5
13
Temporal (no se preserva a través de los llamados)
t6
14
Temporal (no se preserva a través de los llamados)
t7
15
Temporal (no se preserva a través de los llamados)
s0
16
Temporal que debe preservarse entre llamados a funciones
s1
17
Temporal que debe preservarse entre llamados a funciones
s2
18
Temporal que debe preservarse entre llamados a funciones
s3
19
Temporal que debe preservarse entre llamados a funciones
s4
20
Temporal que debe preservarse entre llamados a funciones
s5
21
Temporal que debe preservarse entre llamados a funciones
s6
22
Temporal que debe preservarse entre llamados a funciones
s7
23
Temporal que debe preservarse entre llamados a funciones
t8
24
Temporal (no se preserva a través de los llamados)
t9
25
Temporal (no se preserva a través de los llamados)
k0
26
Reservado para el núcleo del Sist. Operativo
Profesor Leopoldo Silva Bijit
30-08-2008
6
Estructuras de Computadores Digitales
k1
gp
sp
fp
ra
27
28
29
30
31
Reservado para el núcleo del Sist. Operativo
Puntero al área global de datos
Puntero al tope de la pila. Stack pointer
Puntero a zona de variables en la pila. Frame pointer
Dirección de retorno (usado en invocaciones a funciones)
Figura 4.6. Registros, sus nombres y usos.
El registro zero, contiene la constante cero, y no puede escribirse en él. En caso de intentarlo, no
es causa de error.
4.4. Ciclo de Ejecución.
El ciclo de ejecución de un procesador puede describirse como una secuencia repetitiva de los
siguientes pasos (después de una etapa de inicio que consiste en determinar la primera
instrucción):
Búsqueda de instrucción:
Obtiene desde la memoria la instrucción que será ejecutada. Debe especificarse cómo obtiene
la primera instrucción.
Decodificación de Instrucción:
Determina el tipo de instrucción y su largo en caso de que la instrucción esté compuesta de
varias palabras. Debe especificarse cómo estarán codificados los operandos, la operación y la
dirección de la próxima instrucción.
Búsqueda de Operandos:
Localiza y obtiene los datos que son los operandos de la instrucción. Esto puede consistir en
accesar registros o la memoria, o decodificar valores que vienen contenidos en la misma
instrucción (operandos inmediatos), lo cual debe especificarse en la instrucción.
Ejecución:
Computa los valores del resultado y determina el estado de éste. Es decir realiza la operación
con los operandos de entrada para generar un resultado. Y a la vez genera información sobre el
resultado, por ejemplo si es positivo, o cero. Debe especificarse las operaciones que pueden
realizarse y los tipos de datos sobre los que se efectuaran acciones.
Almacenamiento de resultados:
Deposita los resultados en la memoria de datos o en registros. Lo cual debe estar especificado
en el código de la instrucción.
Determinación de próxima instrucción:
Determina cuál será la próxima instrucción que será ejecutada a continuación, ya sea por el
cálculo efectuado durante la etapa de ejecución; o escoger por defecto, la siguiente instrucción.
Debe especificarse los mecanismos que se emplearán para la determinación de la próxima
instrucción, ya sea en saltos incondicionales, bifurcaciones o invocaciones a subrutinas.
Los pasos descritos son comunes a todo procesamiento, cualquiera que sea el nivel de las
instrucciones. En algunos casos puede que dos etapas se realicen simultáneamente, o que alguna
etapa no esté presente.
Profesor Leopoldo Silva Bijit
30-08-2008
Organización MIPS
7
Debe notarse que una instrucción debe especificar: los operandos de entrada (y cómo
accesarlos), la operación, dónde depositar el resultado y cuál será la próxima instrucción. En el
caso de instrucciones de máquina, las informaciones anteriores suelen codificarse en grupos de
bits o campos.
4.5. Formatos de Instrucciones MIPS.
Se denomina formato a la forma de la plantilla (virtual) que permite interpretar los campos de
una instrucción.
Como en este procesador RISC (conjunto reducido de instrucciones) interesa la ejecución veloz
de instrucciones, se determinó emplear solamente instrucciones que ocupen una palabra;
descartando así disponer de un repertorio con instrucciones de largo variable (un ejemplo de
estos formatos lo veremos en el procesador 8051).
MIPS posee sólo tres formatos, que se denominan: R, I y J.
4.5.1. Formato R. Para Operaciones.
Op 6
Rs 5
Rt 5
Rd 5
Shamnt 5
Funct 6
Figura 4.7. Formato R.
Se ilustra el tamaño y los nombres de los campos. Se disponen tres registros para especificar las
dos fuentes de datos (rs y rt) y el lugar para almacenar el resultado (rd).
Un grupo de estas instrucciones (las de corrimiento) ocupan el campo Shift Amount, que
permite especificar el número de posiciones de bits, en que se desplazará uno de los operandos;
su tamaño de cinco bits, permite desplazamientos de 0 a 31. Aquellas instrucciones que no
ocupen este campo lo rellenan con ceros.
Para simplificar la unidad combinacional que decodifica la operación a realizar, se fija en las 6
posiciones más significativas, en todos los formatos, el código de operación. Esto limitaría a 64
el número total de operaciones; pero veremos que el número total de operaciones es mayor de
64 y menor de 128. Para resolver esto, y mantener pequeño el código de operación, se emplea la
técnica de expandir el código de operación. Esto se logra empleando, para todas las operaciones,
lógicas y de corrimiento, el código de operación 000000, y diferenciándolas mediante el campo
funct de 6 bits (que también debe considerarse parte del código de operación).
Las instrucciones que operan la administración de memoria y excepciones, también emplean el
formato R, y ocupan el código de operación 010000; y también el campo funct, lo cual posibilita
64 operaciones de este tipo.
De esta forma quedan disponibles 62 códigos para el resto de las instrucciones.
Profesor Leopoldo Silva Bijit
30-08-2008
8
Estructuras de Computadores Digitales
Un procesador con repertorio CISC (conjunto complejo de instrucciones) puede tener un
número total de instrucciones muchísimo mayor; el microprocesador de 8 bits, el Z80, muy
empleado alrededor de los setenta, permitía escribir alrededor de 1000 instrucciones diferentes.
Uno de los repertorios más elaborados de tipo CISC es el 68000; y constituye un ejemplo de la
complejidad que alcanzaron los diseños de computadores, que tenían como objetivo ofrecer a
los programadores conjuntos sofisticados de instrucciones. El abandono de estos repertorios se
debió al cambio de velocidad y comportamiento logrados con procesadores RISC.
4.5.2. Formato I. Para Inmediatas, transferencias y bifurcaciones.
Op 6
Rs 5
Rt 5
Inmediato 16
Figura 4.8. Formato I.
En las inmediatas: se emplean los 16 bits, menos significativos, con un valor. En la instrucción
se programa una constante. De acuerdo a estadísticas no conviene que el tamaño del campo
inmediato sea menor de 16 bits, esto explica el no emplear un código de operación mayor.
Entonces basta especificar dos registros, uno para el otro operando (rs) ; el otro para depositar el
resultado (rt).
En operaciones lógicas se extienden los 16 bits a 32 con ceros en la parte más significativa. Si la
operación es aritmética se extiende con signo (esto se verá más adelante).
En las transferencias: el registro, especificado en Rs, se emplea como registro base, y el valor
inmediato se interpreta como un desplazamiento (con signo) de 16 bits, los cuales permiten
determinar una dirección efectiva de la memoria. Rt especifica el registro donde guardar
(cargar) el dato leído desde la memoria en una operación load; y también el valor que será
escrito en una palabra de la memoria en una operación store.
En las bifurcaciones: los registros especifican los operandos que serán comparados. Y el campo
de 16 bits se interpreta como un desplazamiento, con signo, relativo a PC.
En algunas bifurcaciones en que se compara un registro con el valor cero, el registro Rt se llena
con ceros. En otras bifurcaciones, también con respecto al valor cero, se emplea el campo Rt,
para expandir el código de operación como se verá más adelante.
4.5.3. Formato J. Para Saltos (Jumps).
Op 6
Dirección 26
Figura 4.9. Formato J.
Profesor Leopoldo Silva Bijit
30-08-2008
Organización MIPS
9
El campo de 26 bits se emplea para configurar una dirección de salto, como se verá más
adelante.
4.6. Repertorio MIPS I (tipo load-store).
4.6.1. Descripción general de las Operaciones.
La siguiente descripción permite lograr una visión global del repertorio de la Unidad Central,
posibilitando así comenzar a programar con todo el repertorio a disposición. El texto guía
introduce algunas sentencias assembler en forma gradual, destacando con mayor profundidad
compromisos y principios de diseño; y es muy recomendable su lectura cuidadosa.
Ayuda bastante, en la familiarización con el repertorio de instrucciones, el ejercitarse ejecutando
las diferentes instrucciones en un simulador (SPIM en este caso).
En las descripciones se ha preferido dejar en idioma inglés los nombres para facilitar el recuerdo
de los códigos simbólicos de las instrucciones.
Como se verá más adelante, las instrucciones que operan sobre direcciones deben usar las
instrucciones aritméticas sin signo. Las que tratan enteros con signo, obviamente deben emplear
instrucciones con signo.
4.6.2. Aritméticas y Lógicas.
Formato R. (10 instrucciones). Todas de tres operandos.
Add, AddU, Sub, SubU, And, Or, Xor, Nor, SLT, SLTU
Instrucción
add
Ejemplo
add
$t1, $t2,$t3
Significado en C.
$t1 = $t2 + $t3
add unsigned addu
subtract
sub
$t1,$t2,$t3
$t1,$t2,$t3
$t1 = $t2 + $t3
$t1 = $t2 – $t3
subtract
unsigned
and
or
xor
nor
set on less
than
set less than
unsigned
subu
$t1,$t2,$t3
$t1 = $t2 – $t3
and
or
xor
nor
slt
$t1,$t2,$t3
$t1,$t2,$t3
$t1,$t2,$t3
$t1,$t2,$t3
$t1,$t2,$t3
sltu
$t1,$t2,$t3
$t1 = $t2 & $t3
$t1 = $t2 | $t3
$t1 = $t2 ^ $t3
$t1 = ~($t2 | $t3)
if ($t2 < $t3) $t1=1;
else $t1=0;
if ($t2 < $t3) $t1=1;
else $t1=0;
Comentarios
si hay rebalse genera
excepción
no genera excepción
si hay rebalse genera
excepción
no genera excepción
or exclusivo. ⊕
Compara números.
(con signo).
Compara números naturales
(sin signo).
Figura 4.10. Istrucciones aritméticas y lógicas. Formato R.
Profesor Leopoldo Silva Bijit
30-08-2008
10
Estructuras de Computadores Digitales
slt compara el contenido de dos registros (que contienen números con signo) y coloca (set) el
registro destino en uno si el registro en la segunda posición es menor que el que está en la
tercera posición.
Se emplea la notación del lenguaje C, para representar la expresión que describe lo que realiza
la instrucción (semántica).
Sobre números con signo.
Algunas de las instrucciones son para números sin signo (llevan una u al final, por unsigned).
Los enteros se representan en una palabra de la memoria, y sus valores dependen del ancho de
palabra que tenga la memoria (en MIPS son de 32 bits).
El procesador emplea representación complemento a dos para representar números con signo.
Suponiendo un largo de palabra de la memoria de 3 bits (en lugar de 32), para simplificar la
explicación, se tienen las siguientes representaciones:
Representación
interna
Secuencia
Binaria
000
001
010
011
100
101
110
111
Representación Externa. Equivalente Decimal.
Sin
signo
0
1
2
3
4
5
6
7
Enteros
Comp. Comp.
a dos
a uno
+0
+0
+1
+1
+2
+2
+3
+3
-4
-3
-3
-2
-2
-1
-1
-0
SignoMagnitud
+0
+1
+2
+3
-0
-1
-2
-3
Fracciones
Sin
Con signo.
signo
Comp. dos
0
+0
1/8
+1/4
2/8
+2/4
3/8
+3/4
4/8
-4/4
5/8
-3/4
6/8
-2/4
7/8
-1/4
Figura 4.11. Interpretación de secuencias binarias numéricas.
Nótese que en todas las representaciones de números negativos, el bit más significativo
corresponde al signo del número, detalles se verán más adelante.
Para obtener un número en complemento a uno, basta cambiar sus unos por ceros y sus ceros
por unos.
Si tenemos: 010, su complemento uno es 101. Y el complemento uno de 101 es 010.
El negativo de un número se obtiene complementándolo.
Profesor Leopoldo Silva Bijit
30-08-2008
Organización MIPS
11
El complemento a dos es el complemento a uno más uno (sumarle uno en binario). Esto se
insinúa con pequeñas flechas en las columnas de las representaciones externas, en decimal. Las
columnas de interpretación, de las secuencias binarias, están desplazadas en la unidad.
Si tenemos: 010, su complemento 1 es 101 y al sumarle uno queda: 101 + 1 = 110
Si tenemos: 101, su complemento 1 es 010 y al sumarle uno queda: 010 + 1 = 011
El negativo de un número se obtiene complementándolo, excepto para el mayor negativo que no
tiene complemento en tres cifras. De esta manera para restar, basta sumar el complemento.
Nótese que en complemento a uno existen dos ceros; pero el rango de representación es
simétrico. Electrónicamente es sencillo generar el complemento a uno de una palabra:
A2
A1
A0
Comp
B2
B1
B0
Figura 4.12. Generación complemento a uno.
Si Comp ==1 se tiene que B es complemento uno de A; en caso contrario: B = A.
En complemento a dos, existe un cero, pero con rango de representación asimétrico.
Para 16 bits, en C-2(complemento dos), el rango de representación es desde -(2^15) hasta
+(2^15 )-1; lo cual equivale al intervalo desde -32768 hasta +32767.
Electrónicamente es sencillo realizar sumas o restas en complemento dos. Mediante un sumador
binario, basta incorporar un uno a la reserva de entrada y pasar el sustraendo en complemento a
uno, para realizar restas. El esquema siguiente ilustra lo anterior:
Profesor Leopoldo Silva Bijit
30-08-2008
12
Estructuras de Computadores Digitales
A2
A1
A0
Comp = 1
Cin
B2
~A2 B1
S. C.
~A1 B0
~A0
S. C.
S. C.
C0
S2 C1
S0
S1
Figura 4.13. Sumas y restas en complemento a dos.
C2
Nótese que Cin puede unirse a Comp. Para restar se requiere Cin = 1 y Comp = 1; y para sumar,
ambas señales deben ser cero.
La red combinacional que se ilustra en el diagrama anterior permite sumar y restar números; se
ilustra el caso de la resta (B - A), ya que se ingresa al sumador el complemento a dos del
operando A.
El bloque, denominado S.C., por sumador completo de un bit, tiene tres entradas y dos salidas,
con la siguiente tabla de verdad:
Bi
0
0
0
0
1
1
1
1
Ai Cini
0
0
0
1
1
0
1
1
0
0
0
1
1
0
1
1
Entradas
Couti Si
0
0
0
1
0
1
1
0
0
1
1
0
1
0
1
1
Salidas
Figura 4.14. Tabla de verdad del sumador completo.
La real ventaja del sistema complemento a dos (respecto al sistema complemento a uno), es que
las redes combinacionales para efectuar comparaciones, con y sin signo, son más sencillas de
realizar, como se verá en detalle más adelante.
Profesor Leopoldo Silva Bijit
30-08-2008
Organización MIPS
13
En el caso de corrimientos aritméticos (de números con signo, en complemento a dos), debe
notarse que las posiciones que quedan vacías por la izquierda deben rellenarse con el bit del
signo. También, debido a que el sistema es posicional, un corrimiento aritmético a la derecha es
equivalente a una división entera por dos, en la que se descarta el resto.
El siguiente ejemplo, con largo de palabra igual a cinco, ilustra lo anterior:
El entero decimal 14, con signo, se expresa en binario según: 01110. Al correrlo a la derecha,
en una posición, debería resultar el decimal 7. El cual en binario es: 00111.
El entero decimal -14, con signo, se expresa según: 10010. Al correrlo aritméticamente a la
derecha, en una posición, debería resultar el decimal -7. El cual en binario es: 11001.
Cuando sale un cero, por la derecha, el resultado es exacto.
El entero decimal 15, con signo, se expresa según: 01111. Al correrlo a la derecha, en una
posición, resulta el binario 00111, que equivale al 7. Se produce truncamiento.
El entero decimal -15, con signo, se expresa según: 10001. Al correrlo a la derecha, en una
posición, resulta el binario 11000, que equivale al decimal -8. También se produce
truncamiento.
4.6.3. Corrimientos Aritméticos y Lógicos.
Formato R. (6 instrucciones). Todas de tres operandos.
SLL, SRL, SRA, SLLV, SRLV, SRAV
La palabra shift significa corrimiento. Left significa izquierdo. Right significa derecha.
Instrucción
shift left logical
shift right logical
shift right arithm.
shift left logical var.
shift right logical
var
Ejemplo
sll
$t1,$t2,10
srl
$t1,$t2,10
sra
$t1,$t2,10
sllv
$t1,$t2,$t3
srlv
$t1,$t2,$t3
Significado en C.
$t1 = $t2 << 10
$t1 = $t2 >> 10
$t1 = $t2 >> 10
$t1 = $t2 << $t3
$t1 = $t2 >> $t3
Comentarios
Inmediato(por constante)
Inmediato(por constante)
Con signo. Divide.
Variable(por registro)
Variable(por registro)
Figura 4.15. Corrimientos aritméticos y lógicos.
Cuando se pasa el argumento del corrimiento en registros, sólo se consideran los cinco bits
menos significativos de este argumento.
Ejemplo: si $a1 tiene almacenado 33 decimal, la instrucción sllv $a0, $a0, $a1 tiene el mismo
efecto que sll $a0, $a0, 1.
Profesor Leopoldo Silva Bijit
30-08-2008
14
Estructuras de Computadores Digitales
4.6.4. Aritméticas y Lógicas. Inmediatas.
Formato I. (8 instrucciones).
AddI, AddIU, AndI, OrI, XorI, SLTI, SLTIU, LUI
Instrucción
add immediate
Ejemplo
addi $t1,$t2,100
Significado en C.
$t1 = $t2 + 100
add
imm.
unsigned
and immediate
or immediate
xor immediate
set less than
imm
addiu $t1,$t2,100
$t1 = $t2 + 100
andi
ori
xori
slti
$t1 = $t2 & 10
Extendido con ceros.
$t1 = $t2 | 10
Extendido con ceros.
$t1 = $t2 ^10
Extendido con ceros.
if ($t2 < 100) $t1=1; Compara menor que, con
else $t1=0;
constante inmediata. Con
signo.
if ($t2 < 100) $t1=1; Compara menor que, sin
else $t1=0
signo. Números naturales.
(16 bits corridos a la
izquierda en 16
posiciones)
$t1,$t2,10
$t1,$t2,10
$t1,$t2,10
$t1,$t2,100
set less than sltiu $t1,$t2,100
imm. uns.
load
upper lui
$t1, 40
immediate
Comentarios
Genera excepción.
Con signo.
No genera excepción.
Figura 4.16. Instrucciones aritméticas y lógicas.
El valor inmediato es una constante que puede expresarse en 16 bits. Con signo, en el caso de
addi y slti; y sin signo, en caso de addiu y sltiu. Por ejemplo 0x12345 no puede expresarse en
16 bits, requiere 17.
En operaciones aritméticas inmediatas con signo, el operando inmediato de 16 bits debe
extenderse a 32, antes de realizar la operación de suma o comparación. El bit 15 del operando
inmediato (el más significativo), es el bit del signo; es uno si el número es negativo y cero si es
positivo.
Si tenemos largo 3, el decimal -1 se expresa según: 111.
Si tenemos largo 6, el decimal -1 se expresa según: 111111.
Entonces para extender, con signo, a 32 bits, en las posiciones 31 a 16 se coloca el valor del bit
15 del inmediato. Esto es sencillo de implementar electrónicamente, como se verá más adelante.
4.6.5. Accesos a Memoria.
Formato I. Transferencias de datos.
LB, LBU, LH, LHU, LW, LWL, LWR
SB, SH, SW, SWL, SWR
Profesor Leopoldo Silva Bijit
30-08-2008
(7 instrucciones)
(5 instrucciones)
Organización MIPS
Instrucción
Load byte
15
Ejemplo
LB
$t1, 40($t2)
Load
byte LBU
unsigned
Load
LH
halfword
Significado en C.
$t1 = M[ ($t2) + 40]
$t1, 40($t2)
$t1 = M[ ($t2) + 40]
$t1, 40($t2)
$t1 = M[ ($t2) + 40]
Load
halfword
unsigned
Load word
Store byte
LHU
$t1, 40($t2) $t1 = M[ ($t2) + 40]
LW
SB
$t1, 40($t2)
$t1, 41($t2)
$t1 = M[ ($t2) + 40]
M[ ($t2)+ 41] = $t1
Store half
SH
$t1, 42($t2)
M[ ($t2)+ 42] = $t1
Store word
SW
$t1,100($t2)
M[ ($t2)+ 100] = $t1
Comentarios
rellena 24 primeras posiciones
de $t1 con bit signo.
rellena 24 primeras posiciones
de $t1 con ceros.
Rellena primeras 16 posiciones
de $t1 con bit signo. La
dirección
efectiva
debe
terminar en 00 ó en 10(en
binario).
rellena primeras 16 posiciones
de $t1 con ceros.
Carga los ocho bits menos
significativos de $t1 en el byte
apuntado por la dirección
efectiva.
Almacena los 16 bits menos
significativos de $t1, en la
media palabra apuntada por la
dirección
efectiva.
Esta
dirección debe terminar en 00
ó en 10(en binario).
La dirección efectiva debe
terminar en 00 (en binario; es
decir, debe ser la dirección de
una palabra alineada).
Figura 4.17. Movimientos entre registros y memoria.
El campo inmediato se interpreta como un número con signo, y corresponde al offset(respecto
del registro base) en bytes.
4.6.6. Multiplicación y División. (8 instrucciones, en formato R).
No existe una referencia para el destino, ya que los resultados se expresan en dos partes de 32
bits, se rellena con ceros el campo destino, cuando la instrucción no lo requiera. Se emplean dos
registros denominados HI (por high) y LO (por Low), para depositar el resultado.
Profesor Leopoldo Silva Bijit
30-08-2008
16
Estructuras de Computadores Digitales
4.6.6.1. Inicio de multiplicación y división entera.
MULT, MULTU, DIV, DIVU
Instrucción
multiply
multiply
unsigned
divide
Ejemplo
mult $t2,$t3
multu $t2,$t3
Significado en C.
Hi, Lo = $t2 * $t3
Hi, Lo = $t2 * $t3
Comentarios
producto de 64-bit con signo
producto de 64-bit sin signo
div
divide
unsigned
divu $t2,$t3
Lo = $t2 ÷ $t3
Hi = $2 mod $3
Lo = $t2 ÷ $t3
Hi = $t2 mod $t3
Lo = cuociente
Hi = resto
Lo = cuociente sin signo
Hi = resto
$t2,$t3
Figura 4.18. Inicio de multiplicación o división.
4.6.6.2. Move result from.
Mueve el resultado de la multiplicación o división a un registro del procesador.
MFHI, MFLO
Instrucción
Move from Hi
Move from Lo
Ejemplo
mfhi $t1
mflo $t1
Significado en C.
$t1 = Hi
$t1 = Lo
Comentarios
Obtiene copia de Hi
Obtiene copia de Lo
Figura 4.19. Mueve el resultado.
4.6.6.3. Move to HI or LO.
MTHI, MTLO rd
Instrucción
Move to Hi
Move to Lo
Ejemplo
mthi $t1
mtlo $t1
Significado en C.
Hi = $t1
Lo = $t1
Comentarios
Carga registro Hi
Carga registro Lo
Figura 4.20. Carga registros en la unidad de multiplicación.
Profesor Leopoldo Silva Bijit
30-08-2008
Organización MIPS
17
4.6.7. Comparaciones y Bifurcaciones. (8 instrucciones, en formato I)
4.6.7.1. Comparaciones entre registros y bifurcación.
Las siguientes comparaciones entre registros seguidas de una bifurcación se describen en
assembler y mediante las transferencias lógicas que realizan:
assembler
Transferencias lógicas
BEQ rs, rt, offset if R[rs] == R[rt] then PC =( PC+4) + offset*4;
BNE rs, rt, offset if R[rs] <> R[rt] then PC =( PC+4) + offset*4;
Instrucción
Branch on
equal
Ejemplo
beq $t1,$t2,100
Significado en C.
if ($t1 == $t2)
PC =(PC+4)+100*4;
branch on not
eq.
bne $t1,$t2,100
if ($t1!= $t2)
PC =(PC+4)+100*4;
Comentarios
Test de igualdad. Bifurcación
relativa a PC en el número de
instrucciones indicadas en el
campo inmediato (con signo).
Test de desigualdad, salto
relativo a PC.
Figura 4.21. Comparaciones entre registros.
El campo inmediato es el número, con signo, de instrucciones.
En la programación assembler el campo inmediato se escribe como un rótulo. Es decir un
identificador de la dirección hacia donde continuar ejecutando instrucciones si se cumple la
condición. El ensamblador calcula el campo inmediato numérico que se requiere. Delegar esta
tarea a un programa fue una gran contribución a la programación; ya que si, por ejemplo, se
intercalara una instrucción, deberían recalcularse los saltos relativos. Nótese que los saltos son
relativos a la dirección de la próxima instrucción (PC+4).
Todas las comparaciones (mayor que, mayor o igual que, menor que, menor o igual que, igual
que, diferente de) pueden implementarse en base a slt y beq.
Lo cual puede concluirse de la siguiente tabla, en la cual se ha empleado los operadores del
lenguaje C, para escribir las expresiones. Todas las construcciones se elaboran en base al
operador < , menor que.
Expresión relacional
a <= b
a==b
a != b
a>=b
a>b
Expresión lógica equivalente
~( b < a )
( a<= b) & ( b <= a )
~( a = = b)
b <= a
b<a
En base a op. <
~( b < a )
~(b<a)&(~(a<b))
(b<a) | (a<b)
~( a < b )
b<a
Figura 4.22. Operadores relacionales.
Profesor Leopoldo Silva Bijit
30-08-2008
18
Estructuras de Computadores Digitales
Puede usarse otro operador relacional (en lugar del menor, mostrado antes) a partir del cual
lograr todos los operadores relacionales.
4.6.7.2. Comparaciones de un registro con cero, seguida de bifurcación.
assembler
BLEZ rs, offset
BGTZ rs, offset
BLTZ rs, offset
BGEZ rs, offset
BLTZAL rs, offset
BGEZAL rs, offset
Transferencias lógicas
if R[rs] <= 0 then PC =( PC+4) + offset*4;
if R[rs] > 0 then PC =( PC+4) + offset*4;
if R[rs] < 0 then PC =( PC+4) + offset*4;
if R[rs] >= 0 then PC =( PC+4) + offset*4;
if R[rs] < 0 then {ra = (PC+4); PC =(PC+4) + offset*4;}
if R[rs] >= 0 then {ra = (PC+4); PC =(PC+4) + offset*4;}
Figura 4.23. Comparaciones con cero.
ra es el mnemónico de return address y corresponde al registro $31.
Se pueden realizar otras comparaciones y bifurcaciones con dos instrucciones (ver macros en
assembler).
4.6.7.3. Estadísticas relativas a bifurcaciones.
Estadísticas muestran que en el caso de procesamiento de enteros, la frecuencia de ocurrencia de
bifurcaciones en promedio, por tipo es: 86 % pertenecen al grupo equal y no equal; un 7% al
grupo LT, GE y el 7% restante al grupo GT.
En caso de punto flotante, como se enseña en un curso de programación, se evitan las
comparaciones con cero. La frecuencia del grupo LT, GE es de un 40 %, la de GT, LE es de un
23%; y la del grupo EQ, NE es de un 37%.
Otro aspecto estadístico notable es que las bifurcaciones en comparación entre enteros, en un
25% de los casos saltan a instrucciones ubicadas a 3 ó 4 instrucciones de la bifurcación, tanto
hacia delante como hacia atrás. En general, la tendencia central de la distribución está ubicada
en más o menos 16 instrucciones relativas a la posición donde se encuentra la bifurcación.
Lo anterior implica una localidad espacial del código (instrucciones); esto quiere decir que al
ejecutarse un programa es muy probable que en un pequeño grupo de palabras adyacentes de
memoria estén las instrucciones que corrientemente se están ejecutando (esto justifica la
incorporación de memoria caché, como se verá más adelante).
Profesor Leopoldo Silva Bijit
30-08-2008
Organización MIPS
19
4.6.7.4. Flujo de ejecución. Flags.
En los diseños de computadores se han empleado tres técnicas para implementar el cambio de
flujo de la secuencia de ejecución de instrucciones. En los diagramas de flujo se suele dibujar un
rombo, del modo siguiente, para indicar un cambio de la secuencia de ejecución:
Figura 4.24. Decisión.
Esta componente está presente en las alternativas (if then else) y en las repeticiones (while,
repeat until, y for).
a) Códigos de condición:
Cuando se efectúa una operación aritmética, se registran en flip-flops algunas condiciones (o
flags) de interés (rebalse, resultado cero, paridad del resultado, reserva de salida, resultado
positivo, resultado negativo). Esta información suele agruparse en un registro de estado del
procesador. Debe notarse que además de efectuar la operación se setean las condiciones; por
esta razón se dice que esto es un efecto lateral. Luego las instrucciones de bifurcación o saltos
condicionales se implementan encuestando a dichos bits.
Esta metodología está ampliamente difundida, y es la que emplea el microcontrolador 8051, por
ejemplo. Su principal ventaja es que logra reducir el número de instrucciones para implementar
una decisión.
Entonces el bloque de decisión se implementa ejecutando dos instrucciones, una que efectúa el
seteo de los flags y la sigue a continuación una instrucción de bifurcación.
Desgraciadamente no todas las instrucciones setean dichos bits del mismo modo, y el
programador debe conocer una tabla de estados de los códigos de condición después de
realizada cada instrucción. En esa tabla existen muchas condiciones superfluas, lo cual produce
confusión, si no se la tiene presente.
La mayor desventaja de esta metodología es que provoca una dependencia entre las dos
instrucciones: la que setea las condiciones y la que hace un test sobre éstas. En el caso de
ejecución traslapada (segmentada o pipeline) esta forma de diseño provoca dificultades, esto
podrá comprenderse más adelante. Lo importante, por el momento, es aceptar que en máquinas
segmentadas no se diseña con códigos de condición, y se emplea instrucciones de Comparación
y salto (punto c).
Por ejemplo, la repetición de un bloque de instrucciones, que comienza en el rótulo bloque,
mientras el registro R sea mayor que cero, puede codificarse:
Profesor Leopoldo Silva Bijit
30-08-2008
20
Estructuras de Computadores Digitales
bloque:
.....
sub
brp
R, R, #1
bloque
;R--, se le resta un inmediato de valor uno a R. Setea flags.
; salto condicional con el flag Plus (resultado positivo)
b) Registro de Condiciones.
Los flags son ahora seteados sólo por instrucciones especiales de comparación. Las operaciones
aritméticas o de corrimiento no producen las condiciones. Esta forma evita los efectos laterales
y ofrece una metodología más simple para programar los bloques de decisión. Su desventaja
está en que se requieren más instrucciones que en el caso anterior.
Por ejemplo, la repetición de un bloque de instrucciones, que comienza en el rótulo bloque,
mientras el registro R sea mayor que cero, puede codificarse:
bloque:
.....
sub
R, R, #1
;R--, se le resta un inmediato de valor uno a R.
cmp
R, #0
;compara R con el inmediato 0. Setea flag.
brp
bloque
; salto condicional con el flag Plus(resultado positivo)
En MIPS se dispone de la instrucción set on less, que efectúa una comparación entre registros y
setea un registro. Y luego puede efectuarse una comparación empleando el registro zero.
Se usa $t2 como registro de condiciones y $t1 como el registro R.
bloque:
.....
slt
bne
$t2, $zero, $t1 ; if ( 0< t1) t2= 1; else t2 =0;
$t2, #zero, bloque
; Si t2 no es cero, repite el bloque
c) Instrucción de Comparación y Bifurcación.
En este caso la instrucción compara dos operandos y efectúa la bifurcación.
Por ejemplo, en MIPS, la repetición de un bloque de instrucciones, que comienza en el rótulo
bloque, mientras el registro R sea mayor que cero, puede codificarse según:
bloque:
.....
BGTZ
$t1, bloque
Se empleó $t1 como el registro R.
4.6.8. Saltos incondicionales y enlace a subrutinas.
Las siguientes son de formato J.
Profesor Leopoldo Silva Bijit
30-08-2008
Organización MIPS
Instrucción
jump
jump and link
21
Ejemplo
j rótulo
jal rótulo
Significado en C.
go to rótulo
$ra = (PC + 4);
go to rótulo;
Comentarios
Salto incondicional.
Para enlazar con subrutina (call )
Figura 4.25. Saltos y enlaces a subrutinas.
La codificación del campo de 26 bits (add26) de la instrucción se logra, según la ecuación:
rótulo = (PC+4)&F0000000+add26*4
donde rótulo simboliza una dirección de 32 bits.
Las siguientes son de formato R.
Instrucción
Ejemplo
Significado en C.
jump register
jr $t1
PC = $t1;
jr $ra
PC = $ra
jump and link
jalr $t1
$ra = (PC + 4); PC = $t1;
vía registro
Comentarios
go to $t1
Para retorno de subrutina
Para enlazar con subrutina (call )
Figura 4.26. Saltos y enlaces en formato R.
4.6.9. Control de coprocesadores.
Se tienen cerca de 10 instrucciones, en formato R.
Algunos ejemplos: syscall, break, nop, rfe, etc..
Para mayores detalles del repertorio, ver manual del programador.
4.7. Modos de direccionamiento MIPS.
Registro (directo):
El valor efectivo del operando es el contenido en el registro.
Inmediato:
El valor del operando es el campo inmediato de 16 bits.
Si el operando es un valor lógico, se extiende a 32 agregando ceros.
Si el operando es aritmético se extiende con signo a 32 bits.
Base+índice:
Se usa en load, store.
El contenido de rs + inmediato (extendido en forma aritmética) es la dirección efectiva.
El campo inmediato se interpreta como el número de bytes relativo al registro base.
Profesor Leopoldo Silva Bijit
30-08-2008
22
Estructuras de Computadores Digitales
Relativo a PC:
En bifurcaciones (branch )
Al valor de PC se le suma el valor inmediato extendido en forma aritmética.
El valor inmediato es el número de instrucciones que salta.
En saltos ( j, jal,jr):
El valor inmediato (que en este caso es de 26 bits) se multiplica por cuatro (de esta
forma quedan 28 bits), y los primeros 4 bit se toman del valor de PC de la instrucción siguiente
(formando así los 32 de la dirección).
Otros modos.
El direccionamiento del tipo registro indirecto, puede lograrse con el de base+offset, empleando
offset cero.
En base a estos direccionamientos pueden obtenerse otros más complejos. Pero se requiere
ejecutar más de una instrucción.
Existen algunos macros en el ensamblador que operan de este modo. Ejemplos son la (por load
address) y li (por load immediate), Move (por mover de un registro a otro).
Como no se puede cargar un inmediato de 32 bits en un registro. Para poder tener acceso a toda
la memoria, se dispone de la instrucción lui (Load upper immediate). Carga en los 16 bits más
significativos de un registro el campo inmediato. Coloca ceros en los 16 menos significativos.
En repertorios con modos complejos de direccionamiento y operandos que hacen referencias a
la memoria suele emplearse un campo de la instrucción para especificar el modo de
direccionamiento; pero cuando se tiene un modelo de carga-almacenamiento y uno o dos modos
de direccionamiento suele especificarse el modo de direccionamiento a través del código de
operación.
4.8. Niveles de Representación
Cualquier algoritmo (secuencia organizada de acciones para cumplir un objetivo dado) puede
describirse en diferentes niveles.
• Lenguaje de alto nivel. Por ejemplo C.
Puede ser un buen punto de partida para describir en general las ideas. Especifica las variables y
sus tipos, y la acción que se realiza sobre ellos. Reemplaza a un diagrama de flujo, y tiene la
ventaja de que puede ejecutarse y permitir su depuración, hasta comprobar que realiza la acción
requerida.
Por ejemplo la descripción de intercambiar dos elementos de un arreglo, puede representarse
según:
Profesor Leopoldo Silva Bijit
30-08-2008
Organización MIPS
23
1
v[k]
temp = v[ k];
v[ k] = v[ k+ 1];
v[ k+ 1] = temp;
temp
2
3
v[k+1]
Figura 4.27. Intercambio de valores. Swap.
Los números sobre las flechas indican el orden de ejecución de las instrucciones del programa
en C.
Un compilador traduce un lenguaje de alto nivel en assembler.
•
Assembler Simbólico. Por ejemplo un programa MIPS.
La descripción del texto anterior, en assembler, es un nivel más bajo de representación.
$s2
$t0
v[k]
1
4
v[k+1]
2
3 $t1
Figura 4.28. Swap en assembler.
Suponiendo que las variables, almacenadas en la memoria, están asociadas a los registros según
se indica en el diagrama anterior, se tiene que la siguiente secuencia assembler realiza el
intercambio de variables. Nótese que el registro s2 es un puntero al elemento k del arreglo. Y
que el tipo de datos de las variables es entero, esto implica que la dirección de la componente
adyacente mayor esté ubicada a 4 bytes de la dirección de v[k](que está almacenada en s2).
lw $t0, 0($s2)
lw $t1, 4($s2)
sw $t1, 0($s2)
sw $t0, 4($s2)
El texto anterior puede ser traducido a un assembler numérico, en el cual se reemplacen los
registros por sus números:
lw $8, 0($18)
lw $9, 4($18)
sw $9, 0($18)
sw $8, 4($18)
Profesor Leopoldo Silva Bijit
30-08-2008
24
Estructuras de Computadores Digitales
El ensamblador traduce el código assembler a un programa objeto.
El ligador (linker) pasa el programa objeto a una secuencia binaria.
• Lenguaje de Máquina. Binario.
El segmento anterior, una vez reemplazados los campos por sus códigos binarios puede
escribirse en hexadecimal según:
0x8e480000
0x8e490004
0xae490000
0xae480004
Y en binario según:
1000 1110 0100
1000 1110 0100
1010 1110 0100
1010 1110 0100
1000
1001
1001
1000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0100
0000
0100
• Transferencias.
Las instrucciones podrían describirse por las transferencias lógicas que implican, según:
R[8] = MEM[ R[18] + sign_ext(0)]; PC = PC + 4;
R[9] = MEM[ R[18] + sign_ext(4)]; PC = PC + 4;
MEM[ R[18] + sign_ext(0)] = R[9]; PC = PC + 4;
MEM[ R[18] + sign_ext(4)] = R[8]; PC = PC + 4;
Las que a su vez puede ser descritas por secuencias de transferencias físicas entre registros:
IR = MemInst[PC], PC=PC+4;
A = R[18];
S = A + signext(0);
M = MemDat[S];
R[8] = M.
Unidad Instrucción.
Unidad Registros. Lectura.
Unidad Operaciones.
Unidad Memoria Datos.
Unidad Registros. Escritura.
IR = MemInst[PC], PC=PC+4;
A = R[18];
S = A + signext(4);
M = MemDat[S];
R[9] = M.
Unidad Instrucción.
Unidad Registros. Lectura.
Unidad Operaciones.
Unidad Memoria Datos.
Unidad Registros. Escritura.
IR=MemInst[PC], PC=PC+4;
A=R[18], B=R[9];
S = A + signext(0);
MemDat[S] = B.
Unidad Instrucción.
Unidad Registros. Lectura.
Unidad Operaciones.
Unidad Memoria Datos.
IR=MemInst[PC], PC=PC+4;
Unidad Instrucción.
Profesor Leopoldo Silva Bijit
30-08-2008
Organización MIPS
25
A=R[18], B=R[8];
S = A + signext(4);
MemDat[S] = B.
Unidad Registros. Lectura.
Unidad Operaciones.
Unidad Memoria Datos.
Las secuencias anteriores se explicarán más adelante, y dependen de las conexiones internas del
procesador y de los recursos que éste disponga.
•
Control.
En forma alternativa puede describirse las secuencias de las señales de control que activan las
transferencias físicas.
El hardware interpreta el lenguaje de máquina, mediante una secuencia de microinstrucciones,
cuya descripción son las señales de control que se activan en cada ciclo del reloj:.
nPC_sel = “+4”, WEPC , WEIR ;
WEA ;
AluSrc = "Op32", ExtOp = “sign”, AluCtr = “add”,WES ;
MemRd, WEM ;
RegDst = "rt", Memtoreg = "mem", RegWr.
Unidad Instrucción.
Unidad Registros. Lectura.
Unidad Operaciones.
Unidad Memoria Datos.
Unidad Registros. Escritura.
nPC_sel = “+4”, WEPC , WEIR ;
WEA ;
AluSrc = "Op32", ExtOp = “sign”, AluCtr = “add”,WES ;
MemRd, WEM ;
RegDst = "rt", Memtoreg = "mem", RegWr.
Unidad Instrucción.
Unidad Registros. Lectura.
Unidad Operaciones.
Unidad Memoria Datos.
Unidad Registros. Escritura.
nPC_sel = “+4”, WEPC , WEIR ;
WEA ; WEB ;
AluSrc = "Op32", ExtOp = “sign”, AluCtr = “add”,WES ;
MemWr.
Unidad Instrucción.
Unidad Registros. Lectura.
Unidad Operaciones.
Unidad Memoria Datos.
nPC_sel = “+4”, WEPC , WEIR ;
WEA ; WEB ;
AluSrc = "Op32", ExtOp = “sign”, AluCtr = “add”,WES ;
MemWr.
Unidad Instrucción.
Unidad Registros. Lectura.
Unidad Operaciones.
Unidad Memoria Datos.
Las secuencias de control anteriores se explicarán más adelante, y dependen de las conexiones
internas del procesador y de los recursos que éste disponga.
Profesor Leopoldo Silva Bijit
30-08-2008
26
Estructuras de Computadores Digitales
Índice general.
CAPÍTULO 4. .............................................................................................................................................1
ORGANIZACIÓN MIPS...........................................................................................................................1
4.1. MEMORIA...........................................................................................................................................2
4.2. NOMBRES DE LOS TIPOS DE DATOS. (USUALES EN PROCESADORES)...............................................4
4.3. REGISTROS MIPS. ..............................................................................................................................5
4.4. CICLO DE EJECUCIÓN. ........................................................................................................................6
4.5. FORMATOS DE INSTRUCCIONES MIPS. ..............................................................................................7
4.5.1. Formato R. Para Operaciones...................................................................................................7
4.5.2. Formato I. Para Inmediatas, transferencias y bifurcaciones....................................................8
4.5.3. Formato J. Para Saltos (Jumps). ...............................................................................................8
4.6. REPERTORIO MIPS I (TIPO LOAD-STORE). .........................................................................................9
4.6.1. Descripción general de las Operaciones. ..................................................................................9
4.6.2. Aritméticas y Lógicas................................................................................................................9
4.6.3. Corrimientos Aritméticos y Lógicos........................................................................................13
4.6.4. Aritméticas y Lógicas. Inmediatas. .......................................................................................14
4.6.5. Accesos a Memoria. ................................................................................................................14
4.6.6. Multiplicación y División. (8 instrucciones, en formato R). ....................................................15
4.6.6.1. Inicio de multiplicación y división entera. ........................................................................................16
4.6.6.2. Move result from...............................................................................................................................16
4.6.6.3. Move to HI or LO. ...........................................................................................................................16
4.6.7. Comparaciones y Bifurcaciones. (8 instrucciones, en formato I) ...........................................17
4.6.7.1. Comparaciones entre registros y bifurcación. ...................................................................................17
4.6.7.2. Comparaciones de un registro con cero, seguida de bifurcación. ......................................................18
4.6.7.3. Estadísticas relativas a bifurcaciones. ...............................................................................................18
4.6.7.4. Flujo de ejecución. Flags...................................................................................................................19
4.6.8. Saltos incondicionales y enlace a subrutinas...........................................................................20
4.6.9. Control de coprocesadores. ...................................................................................................21
4.7. MODOS DE DIRECCIONAMIENTO MIPS. ............................................................................................21
4.8. NIVELES DE REPRESENTACIÓN .........................................................................................................22
•
Lenguaje de alto nivel. Por ejemplo C. ....................................................................................22
•
Assembler Simbólico. Por ejemplo un programa MIPS...........................................................23
•
Lenguaje de Máquina. Binario..................................................................................................24
•
Transferencias...........................................................................................................................24
•
Control. .....................................................................................................................................25
ÍNDICE GENERAL. ....................................................................................................................................26
ÍNDICE DE FIGURAS. ................................................................................................................................27
Profesor Leopoldo Silva Bijit
30-08-2008
Organización MIPS
27
Índice de figuras.
FIGURA 4.1. DIAGRAMA FUNCIONAL. ........................................................................................................... 1
FIGURA 4.2. NUMERACIÓN BIG-ENDIAN........................................................................................................ 2
FIGURA 4.3. BYTES EN LA MEMORIA............................................................................................................. 3
FIGURA 4.4. NUMERACIÓN LITTLE-ENDIAN. ................................................................................................. 3
FIGURA 4.5. BYTES EN LA MEMORIA............................................................................................................. 3
FIGURA 4.6. REGISTROS, SUS NOMBRES Y USOS. ........................................................................................... 6
FIGURA 4.7. FORMATO R. ............................................................................................................................. 7
FIGURA 4.8. FORMATO I. .............................................................................................................................. 8
FIGURA 4.9. FORMATO J. .............................................................................................................................. 8
FIGURA 4.10. ISTRUCCIONES ARITMÉTICAS Y LÓGICAS. FORMATO R............................................................ 9
FIGURA 4.11. INTERPRETACIÓN DE SECUENCIAS BINARIAS NUMÉRICAS. .................................................... 10
FIGURA 4.12. GENERACIÓN COMPLEMENTO A UNO..................................................................................... 11
FIGURA 4.13. SUMAS Y RESTAS EN COMPLEMENTO A DOS. ......................................................................... 12
FIGURA 4.14. TABLA DE VERDAD DEL SUMADOR COMPLETO. ..................................................................... 12
FIGURA 4.15. CORRIMIENTOS ARITMÉTICOS Y LÓGICOS. ............................................................................ 13
FIGURA 4.16. INSTRUCCIONES ARITMÉTICAS Y LÓGICAS............................................................................. 14
FIGURA 4.17. MOVIMIENTOS ENTRE REGISTROS Y MEMORIA. ..................................................................... 15
FIGURA 4.18. INICIO DE MULTIPLICACIÓN O DIVISIÓN................................................................................. 16
FIGURA 4.19. MUEVE EL RESULTADO. ........................................................................................................ 16
FIGURA 4.20. CARGA REGISTROS EN LA UNIDAD DE MULTIPLICACIÓN........................................................ 16
FIGURA 4.21. COMPARACIONES ENTRE REGISTROS..................................................................................... 17
FIGURA 4.22. OPERADORES RELACIONALES. .............................................................................................. 17
FIGURA 4.23. COMPARACIONES CON CERO. ................................................................................................ 18
FIGURA 4.24. DECISIÓN. ............................................................................................................................. 19
FIGURA 4.25. SALTOS Y ENLACES A SUBRUTINAS. ...................................................................................... 21
FIGURA 4.26. SALTOS Y ENLACES EN FORMATO R. ..................................................................................... 21
FIGURA 4.27. INTERCAMBIO DE VALORES. SWAP........................................................................................ 23
FIGURA 4.28. SWAP EN ASSEMBLER............................................................................................................ 23
Profesor Leopoldo Silva Bijit
30-08-2008