UNIDAD 2: Instrucciones: el lenguaje de las computadoras. 2.1 Introduccin Para comandar una computadora se le debe hablar en su lenguaje.

Las palabras del lenguaje de una mquina son llamadas instrucciones, y su vocabulario es llamado repertorio de instrucciones. En esta seccin se expone el repertorio de instrucciones de una computadora real, considerando una forma entendible para los humanos (ensamblador) y una forma entendible por la computadora (cdigo mquina). Podra pensarse que los lenguajes de mquina son tan diversos como los lenguajes de los humanos, sin embargo no es as, los lenguajes de mquina son muy similares entre s; esto se debe a que todas las computadoras son construidas con tecnologas de hardware basadas en principios fundamentales similares y por que hay unas cuantas operaciones bsicas que todas las mquinas deben proporcionar. Ms an, los diseadores de computadoras tienen una meta comn: Encontrar un lenguaje que haga fcil la construccin del hardware y el compilador; mientras se maximiza el rendimiento y se minimiza el costo. Esta meta ha sido honrada a lo largo del tiempo; la siguiente cita fue escrita antes de que fuera posible adquirir una computadora y es tan cierta actualmente, como lo fue en 1947: Es fcil ver por mtodos lgicos formales que existen ciertos [repertorios de instrucciones] que son en abstracto adecuados para controlar y causar la ejecucin de cualquier secuencia de operaciones. . . . Las consideraciones realmente decisivas desde el punto de vista actual, en seleccionar un [repertorio de instrucciones], son ms de naturaleza prctica: La simplicidad del equipo demandado por el [repertorio de instrucciones], y la claridad de su aplicacin a problemas realmente importantes junto con la velocidad del manejo de esos problemas. Burks, Goldstine, y von Neumann, 1947 La simplicidad del equipo es una consideracin tan valiosa para las mquinas actuales como lo fue en los 50s. La meta de este captulo es mostrar un repertorio de instrucciones que siga este consejo, mostrando como ste es representado en hardware y su relacin con los lenguajes de alto nivel. El repertorio de instrucciones bajo estudio es de una arquitectura MIPS, usado por NEC, Nintendo, Silicon Graphics, y Sony; entre otros. Y es un repertorio de instrucciones tpico diseado en los 80s. 2.2 Operaciones y operandos. Toda computadora debe realizar operaciones aritmticas. La notacin en el lenguaje ensamblador MIPS Add a, b, c Instruye a la computadora a sumar las dos variables b y c, y colocar la suma en a.

Esta notacin es rgida, en el sentido que cada instruccin aritmtica de MIPS realiza una sola operacin y debe tener tres variables (variable en un sentido vago, mas adelante se analizarn los operandos en MIPS). Si se quieren sumar las variables b, c, d y e en la variable a, ser necesaria la secuencia: add add add a, b, c a, a, d a, a, e # La suma de b y c es puesta en a # La suma de b, c y d es puesta en a # La suma de b, c, d y e es puesta en a

Se requiere de tres instrucciones para sumar cuatro variables. Como en todos los ensambladores, cada lnea contiene a lo ms una instruccin. Los comentarios inician con el smbolo # y terminan al final del rengln. El nmero natural de operandos para una operacin aritmtica como la suma es tres, los dos operandos a sumar y el operando donde se colocar el resultado. Por lo que es adecuado que las instrucciones aritmticas cuenten con tres operandos: no ms o menos; de acuerdo con la filosofa de mantener un hardware simple, es evidente que el hardware para un nmero variable de operandos es ms complicado que el hardware para un nmero fijo. Esta situacin ilustra el primero de cuatro principios para el diseo de hardware: Principio de diseo 1: La simplicidad favorece la regularidad. En los ejemplos siguientes se muestra la relacin que existe entre un lenguaje de alto nivel y el cdigo MIPS.

Ejemplo: Compilando dos asignaciones a cdigo MIPS Este segmento de un programa en C contiene cinco variables a, b, c, d y e: a = b + c; d = a e; La traduccin de C al ensamblador MIPS la realiza el compilador correspondiente, mostrar el cdigo MIPS que producira para estas asignaciones. Respuesta: Una instruccin MIPS opera con dos operandos fuentes y pone el resultado en un operando destino. Para dos asignaciones simples, solo se requiere de dos instrucciones: add sub a, b, c d, a, e

Ejemplo: Compilando una asignacin mas compleja Para la siguiente asignacin en C: f = (g + h) (i + j); Qu producira el compilador? Respuesta: El compilador separa la asignacin y utiliza variables temporales, de manera que el resultado es: add add sub t0, g, h t1, i, j f, t0, t1 # La variable temporal t0 contiene g + h # La variable temporal t1 contiene i + j # f obtiene t0 t1, que es (g + h) (i + j)

Hasta el momento no se ha puesto atencin a los smbolos involucrados en el cdigo MIPS, sin embargo, a diferencia de los lenguajes de alto nivel, los operandos de las instrucciones no pueden ser cualquier variable; mas bien quedan limitados por un nmero especial de localidades llamadas registros. Los registros son los ladrillos en la construccin de una computadora, se definen durante el diseo del hardware y quedarn visibles al programador cuando la computadora este completada. El tamao de los registros en la arquitectura MIPS es de 32 bits; los grupos de 32 bits son tan frecuentes que por lo general se les da el nombre de palabra en la arquitectura MIPS. Una principal diferencia entre las variables de un lenguaje de programacin y los registros, es el limitado nmero de registros. MIPS tiene 32 registros, por lo que para una instruccin aritmtica se puede elegir entre 32 registros de 32 bits para los tres operandos. La razn del lmite en 32 registros se explica con el segundo principio del diseo de hardware. Principio de diseo 2: Si es ms pequeo es ms rpido. Un nmero muy grande de registros automticamente incrementa el tiempo del ciclo de reloj, simplemente por que las seales elctricas requieren de ms tiempo cuando necesitan viajar ms lejos. Directivas tales como Si es mas pequeo es ms rpido no son absolutas; 31 registros no pueden ser mas rpidos que 32. Los diseadores de hardware deben tomar muy en cuenta este principio y balancear entre el deseo anormal de los programadores por contar con un

nmero grande de registros con el deseo de los diseadores de mantener un ciclo de reloj rpido. Aunque se podran simplemente considerar los nmeros del 0 al 31 para nombrar a los registros, para no confundirlos con valores constantes, por conveniencia se les antepone el smbolo de pesos ($), de manera que los registros son $0, $1, ..., $31. Adems, para simplificar el trabajo del compilador, los registros que correspondan directamente con los nombres de las variables en alto nivel, se nombrarn con $s0, $s1,...; y los registros temporales sern $t1, $t2, $t3,... Esto slo por convencin, en la tabla 2.1 se muestran estas y otras convenciones utilizadas.
N am e $zero $v0-$v1 $a0-$a3 $t0-$t7 $s0-$s7 $t8-$t9 $gp $sp $fp $ra R egister num ber U sage 0 the constant value 0 2-3 values for results and expression evaluation 4-7 argum ents 8-15 tem poraries 16-23 saved 24-25 m ore tem poraries 28 global pointer 29 stack pointer 30 fram e pointer 31 return address Tabla 2.1 Convenciones utilizadas aplicadas en el uso de registros.

Puede notarse que el registro $0 siempre contendr el valor 0, este convencin es bastante til cuando se realizan comparaciones con cero o brincos condicionales.

Ejemplo: Uso de registros. Se repite el ejemplo anterior, pero al utilizar los nombres de los registros en el cdigo ensamblador. f = (g + h) (i + j); Qu producira el compilador? Respuesta: Suponiendo que las variables f, g, h, i y j se asocian con los registros $s0, $s1, $s2, $s3 y $s4, respectivamente. add add sub $t0, $s1, $s2 $t1, $s3, $s4 $s0, $t0, $t1 # El registro $t0 contiene $s1+ $s2 # El registro $t1 contiene $s3+ $s4 # f obtiene $t0 $t1, que es (g + h) (i + j)

Los lenguajes de programacin usan variables simples que se asocian directamente con registros; sin embargo tambin utilizan estructuras de datos un poco ms complejas como es los arreglos; y es imposible que un arreglo alcance dentro de los registros del procesador.

Control Camino de los datos Procesador Memoria

Entrada

Salida

Fig. 2.1 Cinco componentes clsicos de una computadora

Recordando los cinco elementos clsicos de la computadora (que se repite en la figura 2.1, por conveniencia), se observa que debido al nmero limitado de registros, el lugar mas adecuado para las estructuras de datos es la memoria. Sin embargo, puesto que las instrucciones aritmticas solo se realizan con los operandos en registros, la arquitectura MIPS debe incluir algunas instrucciones que permitan la transferencia de datos de memoria a registros y viceversa. La memoria puede ser considerada como un arreglo unidimensional, grande, con las direcciones actuando como ndices en el arreglo, iniciando en la 0. Por ejemplo, en la figura 2.2, la direccin del tercer dato en memoria es 2 y su valor es Memoria [2] = 10.

Fig. 2.2 Direcciones de Memoria y su contenido en algunas localidades

La instruccin que mueve datos desde la memoria a un registro se le conoce como carga, y su formato es: lw $s0, 100 ( $s1 ) que significa $s0 = Memoria[$s1+ 100 ]

lw es el nombre de la instruccin (load word), el primer registro que aparece es el que ser cargado ($s0, en este caso), luego se incluye una constante (100, en este caso) la cual se

considera como un desplazamiento (offset) y finalmente entre parntesis aparece otro registro ($s1, en este caso), el cual es conocido como registro base. La direccin de la palabra a cargar se forma sumando el valor del registro base con el desplazamiento.

Ejemplo: Carga de memoria. Para la siguiente asignacin en C: g = h + A[8]; Qu producira el compilador? Suponiendo que el comienzo del arreglo A se encuentra en el registro $s0, y que las variables g y h se asocian con los registros: $s1 y $s2, respectivamente. Respuesta: Primero se debe tener acceso a la memoria para la lectura del dato: lw $t0, 8( $s0) # El registro $t0 contiene A[8]

Ahora ya es posible realizar la suma: add $s1, $s2, $t0 # g = h + A[8]

Los compiladores son los que se encargan de asociar las estructuras de datos con la memoria. Por lo que el compilador debe poder colocar la direccin adecuada en las instrucciones de transferencias. Puesto que 8 bits (1-byte) son tiles en muchos programas, la mayora de computadoras conservan el direccionamiento por bytes individuales. Por lo que el direccionamiento por palabras se refiere a la lectura de un conjunto de 4 bytes. Esto significa que las direcciones secuenciales de palabras deben diferir en 4. En la figura 2.2 se mostraron a los datos con direcciones continuas, sin embargo, puesto que se estn considerando palabras (de 32 bits), la distribucin correcta de los datos sera la que se muestra en la figura 2.3. Debido a que las memorias organizan a los datos por bytes, cuando se manejan arreglos de palabras se afecta a los ndices de los mismos, entonces el compilador debe calcular adecuadamente la direccin del dato que ser transferido. En el ltimo ejemplo, para que se haga la lectura correcta del elemento 8 del arreglo A, el desplazamiento debe multiplicarse por 4, de manera que a $s0 se le sume 32 (8x4), as se seleccionar al dato A[8] y no a A[8/4].

Fig. 2.3 Direccionamiento por palabras.

La instruccin complementaria a la carga se llama almacenamiento (store), para transferir un dato desde un registro a la memoria. Su formato es similar al de las instrucciones de carga: sw $s0, 100 ( $s1 ) que significa Memoria[$s1+ 100 ]=$s0 sw es el nombre de la instruccin (store word).

Ejemplo: Carga y Almacenamiento. Para la siguiente asignacin en C: A[12] = h + A[8]; Qu producira el compilador? Suponiendo que el comienzo del arreglo A se encuentra en el registro $s0, y que la variable h se asocia con el registro $s1: Respuesta: Primero se debe acceder a la memoria para la carga del dato: lw $t0, 32( $s0) # El registro $t0 contiene A[8]

Ahora ya es posible realizar la suma: add $t0, $s1, $t0 # El registro $t0 contiene h + A[8]

Por ltimo se realiza el almacenamiento: sw $t0, 48( $s0) # A[12]= h + A[8]

Los ndices del arreglo (8 y 12) se deben multiplicar por 4 para obtener las direcciones adecuadas de los datos en memoria.

Ejemplo: Usando una variable como ndice de un arreglo. La siguiente asignacin utiliza a la variable i como ndice del arreglo A: g = h + A[i]; Qu producir el compilador? Suponiendo que el comienzo del arreglo A se encuentra en el registro $s0, y que las variables g, h e i se asocian con los registros: $s1, $s2 y $s3, respectivamente. Respuesta: Antes de accesar a la memoria se debe obtener la direccin adecuada del dato a leer, puesto que solo se han considerado instrucciones de suma, primero se obtendr i x 4, realizando i + i = 2i, y luego 2i + 2i = 4i: add add $t0, $s3, $s3 $t0, $t0, $t0 # $t0 = i + i = 2i # $t0 = 2i + 2i = 4i

La carga se hace con la instruccin: add $t0, $t0, $s0 # $t0 tiene la direccin de A[i] lw $t1, 0( $t0) # $t1 = A[i] Finalmente se realiza la suma: add $s1, $s2, $t1 # g = h + A[i]

Muchos programas tienen ms variables que registros en el procesador. En consecuencia, el compilador intenta mantener a las variables ms usadas en registros y el resto en memoria, usando cargas y almacenamientos para mover variables entre registros y memoria. El proceso de poner a las variables menos usadas (o aquellas que se usarn posteriormente) en memoria se conoce como derramamiento de registros (spilling registers). El principio de hardware que relaciona el tamao con la velocidad sugiere que la memoria debe ser mas lenta que los registros porque el tamao del conjunto de registros es menor que el de la memoria. El acceso a los datos es ms rpido si los datos estn en registros. Y los datos son ms tiles cuando estn en registros por que una instruccin aritmtica se aplica sobre dos registros, mientras que los accesos a memoria solo manipulan un dato. En conclusin, los datos en los registros en MIPS toman un menor tiempo y tienen una productividad ms alta que los datos en la memoria. Para aumentar el rendimiento, los compiladores MIPS deben usar los registros eficientemente.

2.3 Representacin de instrucciones. Hasta el momento se han considerado algunas instrucciones MIPS compuestas de un nombre (nemotcnico) y una serie de operandos; sin embargo dentro de la computadora las instrucciones se almacenan en memoria como pequeos capacitores cargados o descargados y se transfieren entre dispositivos como seales elctricas con niveles de voltajes altos (5 volts) y bajos (0 volts). Por lo que son suficientes dos smbolos para la representacin de las instrucciones. Un sistema numrico con dos smbolos es el sistema binario, por eso se utiliza para la representacin de las instrucciones. Slo hemos considerado 2 tipos de instrucciones, aritmticas y de transferencia de datos, si las comparamos podremos notar que en ambos casos existen tres operandos, en el caso de las instrucciones aritmticas los tres operandos son registros (y como son 32 registros, con 5 bits es suficiente su representacin) y para las transferencias de datos dos operandos son registros y el tercero es una constante, es evidente que no es posible disponer solo de 5 bits para el valor de la constante, puesto que su valor sera muy limitado. Lo que implica que si se quiere conservar el mismo formato para ambas instrucciones, estas tendran diferentes tamaos. Esto da pie al tercer principio de diseo: Principio de diseo 3: Un buen diseo demanda compromisos. Los diseadores de MIPS enfrentaron el problema de decidir si mantenan a todas las instrucciones del mismo tamao, generando con ello diferentes formatos de instrucciones o si mantenan el formato ocasionando instrucciones de diferentes tamaos. Se comprometieron con el primer punto y buscando regularidad con el tamao de los datos, todas las instrucciones en MIPS son de 32 bits. De manera que se tienen diferentes formatos, las instrucciones aritmticas son del Tipo-R por que solo se aplican sobre registros. El formato para las instrucciones Tipo-R es:
op 6 bits rs 5 bits rt 5 bits rd 5 bits shamt 5 bits funct 6 bits

El significado para cada uno de los campos es: op: Operacin bsica de la instruccin, tradicionalmente llamado opcode. Su valor es 0 en el caso de las operaciones aritmticas. rs: El primer operando fuente. rt: El segundo operando fuente. rd: El registro destino, obtiene el resultado de la operacin. shamt: Cantidad de desplazamiento (shift amount), solo se aplica a las instrucciones de desplazamiento, aqu su valor ser 0 (se revisa mas adelante). funct: Funcin, selecciona una variante de la operacin, por ejemplo, la suma y resta ambas son operaciones aritmticas, pero realizan diferentes operaciones. Su valor es de 32 para la suma y 34 para la resta.

Las instrucciones lw y sw son del tipo-I, por que incluyen una constante (dato inmediato). El formato para las instrucciones del tipo-I es:
op 6 bits rs 5 bits rt 5 bits inmediato 16 bits

En este caso tenemos: op: Su valor es 35 para las cargas y 43 para los almacenamientos. rs: Registro base para la direccin de memoria. rt: Registro a ser cargado o almacenado. inmediato: Constante que corresponde al desplazamiento.

Ejemplo: Trasladando a cdigo mquina. Cul es el cdigo mquina de la instruccin: add $t0, $s1, $s2? Respuesta: Tomando como referencia la tabla 1, el registro $t0 es el 8 , $s1 es el 17 y $s2 es el 18. De manera que la representacin en decimal de esta instruccin es:
0 17 18 8 0 32

Y su representacin binaria corresponde a:

000000 6 bits 10001 5 bits 10010 5 bits 01000 5 bits 00000 5 bits 100000 6 bits

Ejemplo: Trasladando cargas y almacenamientos. La asignacin en C: A[12] = h + A[8]; Produjo el siguiente cdigo en ensamblador: lw add sw $t0, 32( $s0) $t0, $s1, $t0 $t0, 48( $s0) # El registro $t0 contiene A[8] # El registro $t0 contiene h + A[8] # A[12]= h + A[8]

Cul es su correspondiente cdigo mquina?

Respuesta: La versin decimal del cdigo mquina es:

35 0 43 16 17 16 8 8 8 8 48 32 0 32

Para obtener los nmeros a los que corresponden los registros, puede usarse la tabla 2.1, la versin binaria del cdigo corresponde a:
100011 000000 101011 10000 10001 10000 01000 01000 01000 0000000000100000 01000 00000 100000

0000000000110000

Actualmente las computadoras se construyen bajo dos principios clave: 1. Las instrucciones se representan como nmeros. 2. Los programas pueden ser almacenados en memoria para ser ledos o escritos al igual que los nmeros. Estos principios permiten el concepto del programa almacenado, en la figura 2.4 se muestra la potencialidad de este concepto, especficamente la memoria puede contener el cdigo fuente para un programa editor, el correspondiente cdigo mquina compilado, el texto que el programa compilado est usando, y tambin al compilador que gener el cdigo mquina.

Fig. 2.4 El concepto del programa almacenado, ilustrado por medio de un ejemplo.

2.4 Instrucciones para tomar decisiones Lo que distingue a las computadoras de las simples calculadoras es su capacidad para tomar decisiones basadas en los datos de la entrada. En los lenguajes de alto nivel esta accin se realiza con la expresin if algunas veces acompaada con expresiones goto y etiquetas. La arquitectura MIPS cuenta con dos instrucciones de brincos condicionales. La primera: beq registro1, registro2, L1

compara el contenido del registro1 con el del registro2, si son iguales, la siguiente instruccin ser la que se encuentra ubicada en la etiqueta L1 (beq branch if equal). La segunda instruccin es: bne registro1, registro2, L1

y en este caso el brinco se realizar si los contenidos de los registros no son iguales (bne branch if not equal).

Ejemplo: Compilando una expresin if en un brinco condicional. Para el siguiente cdigo: if ( i == j ) goto L1 f = g + h; f = f i;

L1:

Suponiendo que las cinco variables (f a j) se asocian con los registros ($s0 a $s4) Cul es el cdigo MIPS compilado? Respuesta: beq add sub $s3, $s4, L1 $s0, $s1, $s2 $s0, $s0, $s3 # Se realiza la comparacin # Si no fueron iguales se hace la suma # Si ocurri la igualdad, la siguiente instruccin es la # resta

L1:

Los compiladores se encargan de colocar etiquetas cuando stas no aparecen en el cdigo de alto nivel. Esta es otra ventaja de la escritura de programas en lenguajes de alto nivel. Como un complemento a los brincos condicionales, la arquitectura MIPS cuenta con la instruccin: j Etiqueta

Por medio de la cual se realiza un salto incondicional, de manera que la siguiente instruccin a ejecutarse es la que se especifica despus de la etiqueta.

Ejemplo: Compilando una estructura if-then-else. Para el siguiente cdigo: if ( i == j ) f = g + h; else f = g h; Si nuevamente las se asocian con los registros ($s0 a $s4) Cul es el cdigo MIPS compilado? Respuesta: El compilador generar una serie de etiquetas en forma automtica, de acuerdo al flujo del programa. Una opcin es la siguiente:

De manera que si i == j se contina con la suma y luego un salto a la etiqueta exit. En caso de que la igualdad no se cumpla, se hace el salto a la etiqueta else: bne add j Else: add Exit: $s3, $s4, Else $s0, $s1, $s2 Exit $s0, $s1, $s2 # Si no son iguales brinca a la etiqueta Else # Si fueron iguales hace la suma # y salta a la etiqueta Exit. # Si no fueron iguales hace la resta # y termina la decisin.

Adems de las elecciones entre dos alternativas, con estas instrucciones es posible la ejecucin de ciclos repetitivos.

Ejemplo: Compilando un lazo simple. Se tiene el lazo en C: Loop: g = g + A[i] i = i + j; if( i != h ) goto Loop; Suponiendo que las variables g, h i y j se asocian con los registros $s1, $s2, $s3 y $s4, respectivamente y que el registro base del Arreglo A es $s5 Cul es el cdigo MIPS compilado? Respuesta: Primero se requiere obtener el valor de A[i] en un registro temporal: Loop: add add add lw $t0, $s3, $s3 $t0, $t0, $t0 $t0, $t0, $s5 $t1, 0( $t0) # $t0 = i + i = 2i # $t0 = 2i + 2i = 4i # $t0 contiene la direccin de A[i] # $t1 = A[i]

Luego se realizan las sumas: add add $s1, $s1, $t1 $s3, $s3, $s4 # g = g + A[i] #i=i+j

Por ltimo se hace el brinco condicional: bne $s3, $s2, Loop # Si I != j contina en el lazo.

Las sentencias goto son poco usadas por los entendidos con la programacin estructurada, pero con estas instrucciones es posible la compilacin de los ciclos: while y do-while.

Ejemplo: Compilando un ciclo while. Se tiene el ciclo repetitivo: while (save[i] == k) i = i + j;

Si las variables i, j y k se asocian con los registros $s3, $s4 y $s5, respectivamente y que el registro base del Arreglo save es $s6 Cul es el cdigo MIPS compilado? Respuesta: Para que pueda compararse el valor de save[i], debe obtenerse en un registro temporal: Loop: add add add lw $t1, $s3, $s3 $t1, $t1, $t1 $t1, $t1, $s6 $t1, 0( $t1) # $t1 = i + i = 2i # $t1 = 2i + 2i = 4i # $t1 contiene la direccin de save[i] # $t1 = save[i]

Ahora es posible comparar a save[i] con k, si son diferentes, termina el ciclo: bne $t1, $s6, Exit # si save[i] es diferente de k, termina el ciclo.

Dentro del ciclo se realiza la suma: add $s3, $s3, $s4 #i=i+j

El ciclo se repite: j Exit: Loop # Salta a la siguiente iteracin

La prueba de igualdad o desigualdad para un salto es la mas popular, sin embargo algunas veces es til evaluar si una variable es menor que otra, por ejemplo en los ciclos repetitivos for, en los cuales se va incrementando (o decrementando) una variable y se contina en el ciclo mientras sea menor que otra (o mayor que 0). MIPS cuenta con la instruccin slt (set on less than), que compara dos registros y modifica a un tercero de acuerdo con el resultado de la comparacin. Por ejemplo: slt $t0, $s1, $s2

Pondr un 1 en $t0 si $s1 < $s2, en caso contrario, $t0 contendr 0.

Ejemplo: Prueba de la instruccin slt. Cul es el cdigo que prueba si una variable a (asociada con $s0) es menor que una variable b (asociada con $s1) y brinca a la etiqueta less si la condicin se mantiene? Respuesta:

slt bne

$t0, $s0, $s1 $t0, $zero, less

# $t0 = 1 si a < b y $t0 = 0 en caso contrario # $t0 no es igual a 0, brinca a la etiqueta less

Notar que se est aprovechando el hecho de que el registro cero contiene el valor 0. Las estructuras de decisin if-then-else son ampliamente usadas, sin embargo en muchos programas se tiene diferentes alternativas a seguir despus de evaluar una expresin. Para ello algunos lenguajes manejan estructuras de decisin mltiple, por ejemplo, la estructura switch-case del lenguaje C (o similares). Se espera que una estructura de este estilo sea ms eficiente que mltiples comparaciones individuales. Para conseguirlo, los compiladores deben generar una tabla de direcciones de salto, de manera que se obtenga la direccin destino de la tabla y se realice el salto en forma inmediata. Para tales situaciones, la arquitectura MIPS incluye a la instruccin jr (jump register) la cual realizar un salto incondicional a la direccin contenida en el registro especificado en la instruccin.

Ejemplo: Compilando una estructura switch-case. El siguiente cdigo C selecciona entre cuatro alternativas dependiendo si el valor de k es 0, 1, 2 o 3: switch ( k ) { case 0: case 1: case 2: case 3: } f = i + h; break; f = g + h; break; f = g - h; break; f = i - j; break; /* /* /* /* k = 0 */ k = 1 */ k = 2 */ k = 3 */

Suponer que las seis variable f a k corresponden a los registros $s0 al $s5 y que el registro $t2 contiene 4. Cul es el correspondiente cdigo MIPS? Respuesta: El objetivo es evaluar a la variable k para indexar a la tabla de direcciones, y posteriormente saltar al valor cargado. Pero primero es necesario asegurarse que k est en un caso vlido: slt bne slt $t3, $s5, $zero $t3, $zero, Exit $t3, $s5, $t2 # Prueba si k < 0 # Si k < 0, termina # Prueba si k <4

beq $t3, $zero, Exit # Si k >= 4, termina Si el valor de k es vlido, para que pueda utilizarse como ndice, debe multiplicarse por 4 add add $t1, $s5, $s5 $t1, $t1, $t1 # $t1 = k + k = 2k # $t1 = 2k + 2k = 4k

Supongamos que existen cuatro palabras secuenciales en memoria que inician en la direccin contenida en $t4 y contienen la direccin correspondiente a las etiquetas L0, L1, L2 y L3. Para obtener la direccin adecuada para el salto se utilizan las instrucciones: add lw $t1, $t1, $t4 $t0, 0( $t1) # $t1 = direccin de la tabla_de_saltos[k] # $t1 = tabla_de_saltos[k]

Un salto a registro desviar el flujo del programa a la opcin correspondiente: jr $t0 # salto basado en el registro t0.

Las instrucciones que se realizarn en cada caso, de acuerdo con el valor de k son: L0: L1: L2: L3: Exit: add j add j sub j sub $s0, $s3, $s4 Exit $s0, $s1, $s2 Exit $s0, $s1, $s2 Exit $s0, $s3, $s4 # k = 0 => f = i + j # k = 1 => f =g + h # k = 2 => f = g - h # k = 3 => f = i j # fin del switch-case

Resumen: Los operandos en MIPS son:

Las instrucciones consideradas hasta el momento del repertorio MIPS son:

El lenguaje de mquina para las instrucciones consideradas hasta el momento es:

Tarea 3: 1.- Obtener el cdigo MIPS de la asignacin: x[10] = x[11] + c; Suponer que c corresponde al registro $t1 y el arreglo x tiene una direccin base de 4000. 2.- Escriba el cdigo mquina generado para el ejercicio anterior. 3.- Con el ensamblador MIPS, indique la secuencia de instrucciones que evale a los registros $s0, $s1 y $s2 y deje el valor del menor en $s3. 4.- Escriba el cdigo mquina generado para el ejercicio 3. 5.- El siguiente cdigo acumula los valores del arreglo A en la variable x: for ( x = 0, i = 0; i < 10; i++ ) x = x + A[i]; Cul ser el cdigo MIPS para este cdigo? Suponga que el comienzo del arreglo A esta en el registro $s3, que el registro $t1 contiene 10, que la variable x se asocia con $s1 y la variable i con $s2. 6.- Transforme la siguiente asignacin: c = ( a > b ) ? a : b; a cdigo MIPS. Asocie a, b y c con $s0, $s1 y $s2, respectivamente.