Estructura de Computadores. Capítulo 3b: Programación en

Transcripción

1 Estructura de Computadores Capítulo 3b: Programación en ensamblador del MIPS. José Daniel Muñoz Frías Universidad Pontificia Comillas. ETSI ICAI. Departamento de Electrónica y Automática Estructura de Computadores Capítulo 3b: Programación en ensamblador del MIPS. p. 1 Índice 1. Introducción. 2. Registros disponibles. 3. Operaciones aritméticas. 4. Acceso a memoria. 5. Codificación en lenguaje máquina. 6. Toma de decisiones. 7. Llamadas a funciones. 8. Manejo de caracteres. 9. Aritmética. Estructura de Computadores Capítulo 3b: Programación en ensamblador del MIPS. p. 2

2 Introducción En este tema se va a estudiar en detalle la arquitectura MIPS. Se estudiará: El juego de instrucciones. El lenguaje ensamblador y la codificación de instrucciones. Los recursos disponibles. Cada arquitectura tiene su propio juego de instrucciones y su propio ensamblador, aunque todos son similares. El aprendizaje se apoyará con prácticas de laboratorio. Estructura de Computadores Capítulo 3b: Programación en ensamblador del MIPS. p. 3 En el tema anterior se han estudiado las características que debe cumplir un juego de instrucciones. En este capítulo se va a mostrar en detalle el juego de instrucciones de la arquitectura MIPS, así como las técnicas de programación en ensamblador en dicha arquitectura. Como probablemente sabrá, cada procesador tiene su propia arquitectura y su propio lenguaje ensamblador. Por tanto puede parecer una pérdida de tiempo aprender un ensamblador concreto, ya que éste sólo servirá para programar una arquitectura. No obstante lo anterior no es cierto por dos razones fundamentales: La filosofía de programación en ensamblador es idéntica para todas las arquitecturas. En todas ellas, las operaciones que se pueden realizar son muy básicas y es necesario bajar al nivel de la máquina. Aunque cada arquitectura tiene un juego de instrucciones propio, todas las arquitecturas incorporan una serie de instrucciones básicas con funcionalidades muy parecidas. Por ejemplo todas las arquitecturas incluyen la instrucción ADD para realizar una suma. Las diferencias estarán en el número de operandos que admiten o en el nemónico. Por tanto, una vez que se ha aprendido a programar en ensamblador con una arquitectura, programar otra es cuestión del poco tiempo que lleva familiarizarse con ella. Este tema se basa en el capítulo 3 de (Patterson y Hennessy, 2000). En el laboratorio se usará el simulador SPIM, 1 disponible en: larus/spim.html 1 El nombre SPIM es simplemente MIPS escrito al revés.

3 Registros disponibles MIPS dispone de: 32 registros de 32 bits para enteros 32 registros de 32 bits para coma flotante. Un contador de programa de 32 bits Dos registros de 32 bits para almacenar los resultados de multiplicaciones y divisiones. Existe una convención software para el uso de los registros enteros. Estructura de Computadores Capítulo 3b: Programación en ensamblador del MIPS. p. 4 La primera característica que debe conocer un programador sobre una arquitectura es qué registros están disponibles. En el caso del MIPS, se dispone de un banco de registros para almacenar números enteros y otro para almacenar números en coma flotante. Ambos bancos constan de 32 registros de 32 bits. En el caso del banco de coma flotante, los registros se pueden agrupar de dos en dos para utilizarlos en operaciones con números en doble precisión (64 bits). Además de estos bancos, la arquitectura MIPS define tres registros adicionales: el contador de programa y dos registros llamados Hi y Lo que se utilizan para almacenar el resultado de las operaciones de multiplicación y división enteras. En el caso de la multiplicación, recuerde que el producto de dos números de 32 bits da como resultado un número de 64 bits. De la misma forma, el cociente de dos números de 32 bits da como resultado un cociente de 32 bits y un resto también de 32 bits. Aunque para el procesador todos los registros son iguales, existe una convención seguida por todos los programadores para el uso de los registros para enteros, la cual pasamos a describir a continuación.

4 Registros disponibles 0 zero Constante 0 1 at Reservado para el ensamblador 2 v0 Evaluación de expresiones 3 v1 y retorno de resultados 4 a0 Argumentos de funciones 7 a3 8 t0 Valores temporales La invocada puede modificarlos 15 t7 La invocadora debe guardarlos Estructura de Computadores Capítulo 3b: Programación en ensamblador del MIPS. p. 5 En la tabla de esta transparencia y la siguiente se muestran los registros enteros del MIPS junto con el uso que se debe hacer de ellos. Como se dijo antes, para el procesador todos los registros (excepto el 0) son iguales. Sin embargo para hacer más fácil y eficiente la programación, existe una convención de uso de estos registros que se describe en detalle a continuación: El registro zero contiene siempre la constante 0. La utilidad de este registro se verá más adelante. El registro at está reservado para ser usado por el ensamblador. Los registros v0 y v1 se utilizan para evaluar expresiones y para que las funciones puedan devolver sus resultados. Los registros a0 a3 se utilizan para pasarle argumentos a las funciones. Si son necesarios más de 4 argumentos (o éstos necesitan más de 32 bits) se recurre a la pila. Los registros t0 t7 se utilizan para almacenar valores temporales. Por tanto cualquier función puede usarlos sin preocuparse de guardar su valor anterior. Ahora bien, si una función necesita algún valor almacenado en estos registros ha de guardarlo en otro sitio (memoria, registros) antes de llamar a otra función (la invocada), pues ésta supondrá que dichos registros sólo contienen valores inútiles para quien la ha llamado (la invocadora).

5 Registros disponibles 16 s0 Salvados por la invocada La invocada debe guardarlos 23 s7 antes de usarlos 24 t8 Valores temporales 25 t9 Idem ant. 26 k0 Reservados para el 27 k1 sistema operativo 28 gp Puntero al área global 29 sp Puntero de pila (stack pointer) 30 fp Puntero al bloque de activación (frame pointer) 31 ra Dirección de retorno (return address) Estructura de Computadores Capítulo 3b: Programación en ensamblador del MIPS. p. 6 Los registros s0 s7 se utilizan para almacenar variables que deben ser preservadas entre llamadas a funciones. Por tanto, si alguna función necesita usar alguno de estos registros, ha de guardar antes su valor (por ejemplo en la pila). De esta forma, la función que usa estos registros no ha de preocuparse de guardar sus valores antes de llamar a otra función. Los registros t8 y t9 se utilizan de la misma manera que los registros t0 t7. Los registros k0 y k1 están reservados para el sistema operativo. El registro gp se utiliza para apuntar al área de memoria donde están los datos del programa. Su utilidad se verá más adelante. El registro sp es el puntero de la pila (contiene la dirección del tope de la pila). El registro fp contiene la dirección de la zona de la pila en la que están guardados los argumentos y las variables locales de la función que no caben en los registros. Esta zona se conoce como bloque de activación. Su utilidad es la de simplificar el acceso a estas variables cuando es necesario modificar la pila durante la ejecución de la función (por ejemplo durante la evaluación de expresiones). Por último, el registro ra contiene la dirección a la que debe retornar la función invocada cuando finalice su labor. El funcionamiento detallado de estos tres últimos registros se verá cuando se estudie el mecanismo de llamada a funciones de la arquitectura MIPS.

6 Operaciones aritméticas En las siguientes transparencias se muestran varios ejemplos en ensamblador MIPS para realizar operaciones aritméticas. Se partirá de la expresión en C para estudiar cómo se implanta dicha expresión en ensamblador. Características de las operaciones aritméticas MIPS: Operaciones de 3 direcciones. Operandos y resultados han de estar en registros. Un operando puede ser una constante de 16 bits. Estructura de Computadores Capítulo 3b: Programación en ensamblador del MIPS. p. 7 Para estudiar el ensamblador del MIPS, se van a introducir sus instrucciones principales a través de ejemplos. En estos ejemplos se partirá de un trozo de código en lenguaje C y se estudiará como se implanta dicho código en ensamblador. En primer lugar se van a estudiar algunas de las instrucciones disponibles en la arquitectura MIPS para realizar operaciones aritméticas con números enteros. Todas estas instrucciones, junto con las instrucciones para realizar operaciones lógicas comparten tres características fundamentales: Operaciones de 3 direcciones. La primera dirección será donde se almacene el resultado y las otras dos los operandos. Operandos y resultados han de estar en registros. Por tanto antes de realizar cualquier operación, si alguno de los datos está en memoria será necesario cargarlo en un registro. Un operando puede ser una constante de 16 bits. En estos casos se realiza la operación entre dicha constante y un registro para almacenar el resultado en otro registro.

7 Operaciones aritméticas La expresión en C: int a, b, c; c = a + b; Se traduce en ensamblador (suponiendo la asignación de registros: a->s0, b->s1 y c->s2) como: add $s2, $s0, $s1 Estructura de Computadores Capítulo 3b: Programación en ensamblador del MIPS. p. 8 En este ejemplo, suponemos que las tres variables enteras a, b y c han sido situadas por el compilador en los registros s0, s1 y s2 respectivamente (en el compilador de C del MIPS el tipo int es de 32 bits). La instrucción de suma en el MIPS se representa con el nemónico add. Además, tal como se ha dicho anteriormente, las instrucciones aritméticas del MIPS son de tres direcciones. Esto implica que siempre realizan la operación entre dos registros, o entre un registro y una constante de 16 bits, y almacenan su resultado en un registro. En el ensamblador del MIPS se escribe en primer lugar el registro destino del resultado y a continuación los dos operandos. La restricción de que todas las operaciones aritméticas sean de tres direcciones puede parecer caprichosa. Sin embargo dicha restricción está motivada por el deseo de simplificar la circuitería, ya que si se quisieran implantar instrucciones con distintos números de operandos se necesitaría circuitería específica para cada uno de los casos. Esto se puede resumir en uno de los principios de diseño hardware: Principio de diseño 1: la uniformidad simplifica el hardware. Cabe preguntarse cómo se puede realizar la suma de más de dos variables. En la siguiente transparencia se ilustra con otro ejemplo.

8 Operaciones aritméticas Cómo se traduce en ensamblador la expresión en C? int a, b, c, d, e; a = b + c + d + e; Suponiendo la asignación de registros: a->s0, b->s1, c->s2, d->s3 y e->s4, se necesitan ahora tres instrucciones: add $s0, $s1, $s2 # a contiene b+c add $s0, $s0, $s3 # ahora a vale b+c+d add $s0, $s0, $s4 # y por fin a es b+c+d+e Estructura de Computadores Capítulo 3b: Programación en ensamblador del MIPS. p. 9 Como se puede apreciar, ahora es necesario sumar 4 variables, pero las instrucciones aritméticas del MIPS sólo permiten sumar dos. Para resolver este problema, se realizan tres sumas parciales: 1. b+c 2. b+c+d 3. b+c+d+e Dichas sumas parciales se han ido almacenando en el registro asignado a la variable a (s0). En este ejemplo se ilustran dos cosas nuevas: Un mismo registro puede ser a la vez fuente y destino. Así, en la segunda instrucción se está sumando s0 (que contiene ya b+c) con d y el resultado se vuelve a guardar en s0. El texto que aparece a la derecha del carácter # es un comentario y por tanto es ignorado por el ensamblador. A diferencia de C no es necesario especificar el final del comentario, ya que éste acaba al final de la línea. Si se desean más líneas de comentario será necesario usar caracteres # adicionales en cada línea. También es necesario destacar que cada línea puede contener como mucho una instrucción de ensamblador.

9 Operaciones aritméticas Cómo se traduce en ensamblador la expresión en C? int a, b, c, d, e; a = (b + c) - (d + e); Se realiza la asignación de registros: a->s0, b->s1, c->s2, d->s3 y e->s4. add $t0, $s1, $s2 add $t1, $s3, $s4 sub $s0, $t0, $t1 # se usa t0 para b+c # se usa t1 para d+e # s0 vale ahora t0-t1 Estructura de Computadores Capítulo 3b: Programación en ensamblador del MIPS. p. 10 Para evaluar la expresión a = (b + c) - (d + e) es necesario evaluar en primer lugar las expresiones entre paréntesis y a continuación restar ambos resultados. Para almacenar los resultados de las expresiones entre paréntesis se usan variables temporales, ya que lo más probable es que no necesitemos nunca más dichos resultados. Se han elegido para ello los registros temporales t0 y t1. Otra novedad de este ejemplo es la instrucción sub, la cual resta el tercer argumento del segundo y lo almacena en el primero, es decir: sub $s0, $t0, $t1 hace que s0 = t0 - t1. Ejercicio Modifique el programa anterior para evitar el uso de los dos registros temporales. Pista: Puede usar el registro s0 para ir almacenando los resultados parciales.

10 Acceso a memoria Es necesario acceder a memoria para usar: Vectores y matrices. Estructuras de datos. Variables que no están en registros. Estructura de Computadores Capítulo 3b: Programación en ensamblador del MIPS. p. 11 En los ejemplos mostrados hasta ahora se ha supuesto que todas las variables involucradas en las operaciones estaban almacenadas en los registros del procesador. Ahora bien, esto no siempre es así. Todos los lenguajes de programación soportan tipos de datos complejos que no pueden ser almacenados dentro de unos cuantos registros de 32 bits. Ejemplos claros son los vectores, las matrices y las estructuras de datos. Además, en muchas ocasiones los programas necesitan manejar más variables de las que pueden almacenarse en los registros. En estos casos no queda más remedio que mantener algunas variables en memoria y traerlas a los registros temporales cuando necesitemos operar con ellas. Por último, antes de poder usar una variable es necesario cargarla en un registro. En consecuencia, la arquitectura MIPS, al igual que todas las demás, dispone de instrucciones de transferencia de datos que permiten cargar un valor desde la memoria a un registro y para almacenar un registro en la memoria.

11 Acceso a memoria. Organización El bus de datos del MIPS es de 32 bits. Es posible direccionar cada byte individualmente. Dirección de palabra = dir. byte más significativo: Arquitectura big endian Dirección de palabra = múltiplo de 4 Restricción de alineación Dir Palabra msb lsb 8 9 A B Dir. Byte Estructura de Computadores Capítulo 3b: Programación en ensamblador del MIPS. p. 12 Antes de estudiar en detalle las instrucciones de transferencia de datos del MIPS, es conveniente ver cómo está estructurada su memoria. Los procesadores MIPS tienen un bus de datos de 32 bits, por lo que en cada acceso a memoria se lee una palabra de 32 bits. Como se ha dicho antes, debido entre otras cosas a que un carácter ocupa un byte, es necesario poder acceder a éstos individualmente. Por ello, aunque la memoria física está organizada en palabras de 32 bits, desde el punto de vista lógico (o del programador), la memoria ha de estar organizada en bytes. Para ello, tal como puede apreciarse en la figura, cada palabra está dividida en 4 bytes, cada uno con su dirección para poder acceder a él individualmente. Las direcciones de palabra en este caso coinciden con la del byte más significativo. Se dice entonces que la arquitectura es big endian. Otros ejemplos de arquitecturas big endian son: IBM 360/370, Motorola 68k y Sparc. Existe otra alternativa, seguida fundamentalmente por la arquitectura IA-32 en la que la dirección de palabra coincide con el byte menos significativo. En este caso se dice que la arquitectura es little endian. El que una arquitectura sea big endian o little endian es más o menos transparente al programador. Sólo cuando éste tiene que examinar la memoria en busca de números de más de 8 bits ha de tener en cuenta su organización. Ahora bien, este tema es crítico si se intercambian datos entre dos arquitecturas con distintas endianess. Por último, cabe destacar que en la arquitectura MIPS las direcciones de palabra deben de ser siempre múltiplos de 4. Esto es lo que se conoce como restricción de alineación. Existen arquitecturas que no tienen esta restricción, aunque en estos casos, los accesos a palabras alineadas son mucho más rápidos que a palabras desalineadas.

12 Acceso a memoria. Ejemplos Cómo se traduce en ensamblador la expresión en C? int a, b, V[40]; a = b + V[8]; Se realiza la asignación de registros: a->s0, b->s1, V->s2. lw $t0, 32($s2) # t0 se carga con V[8] add $s0, $s1, $t0 # se realiza la operación Estructura de Computadores Capítulo 3b: Programación en ensamblador del MIPS. p. 13 En este ejemplo, es necesario acceder a un elemento de un vector. Obviamente el vector no cabe en los registros del procesador, por lo que es necesario mantenerlo en la memoria. Ahora bien, lo que sí se puede guardar en los registros internos es la dirección del primer elemento del vector (lo que en C se denota por el nombre del vector). En este ejemplo se supone que se guarda dicha dirección en el registro s2. Por tanto, para acceder a la octava palabra del vector, basta con sumar a la dirección de comienzo del vector el desplazamiento necesario. La instrucción de carga de MIPS, denominada lw (de load word), hace precisamente esto: toma la dirección de un registro base y le suma un desplazamiento, 1 cargando entonces la palabra que hay en la dirección calculada en el registro destino. El formato de la instrucción es por tanto: lw Reg_Dest, Despl(Reg_Base) Hay que tener en cuenta que, según se ha discutido antes, las direcciones de palabra aumentan de 4 en 4, por lo que la octava palabra de un vector estará 8 pal 4Byte/pal = 32Bytes por encima de la base del vector. Por tanto, para cargar V[8] en el registgro t0, si la dirección base del vector V está almacenada en el registro s2, basta con hacer: lw $t0, 32($s2) La instrucción complementaria a lw se denomina sw (de store word). Su funcionamiento es similar al de lw, salvo que en lugar de traer una palabra de la memoria y almacenarla en un registro; toma la palabra almacenada en el registro y la almacena en la memoria, concretamente en la dirección Reg_Base + Despl. En la siguiente transparencia se ilustra su uso mediante otro ejemplo. 1 El desplazamiento puede ser positivo o negativo.

13 Acceso a memoria. Ejemplos Cómo se traduce en ensamblador la expresión en C? int b, V[40]; V[12] = b + V[8]; Se realiza la asignación de registros: b->s1, V->s2. lw $t0, 32($s2) # t0 se carga con V[8] add $t0, $s1, $t0 # se realiza la operación sw $t0, 48($s2) # t0 se guarda en V[12] Estructura de Computadores Capítulo 3b: Programación en ensamblador del MIPS. p. 14 Como se puede apreciar las dos primeras líneas son prácticamente iguales a las del ejemplo anterior: tan solo varía el registro destino de la suma, que ahora es el registro temporal t0, en donde se almacena el resultado de la suma antes de escribirlo en la memoria. De esta escritura en memoria se encarga la instrucción sw, la cual tiene el mismo formato que la instrucción lw: sw Reg_Orig, Despl(Reg_Base) En donde Reg_Orig es el registro cuyo valor se desea guardar y el resto de argumentos tienen el mismo significado que antes. Al igual que antes hay que convertir la dirección de palabra del vector a dirección de byte (12 pal 4Byte/pal = 32Bytes) para obtener el desplazamiento correcto. En la mayoría de los programas, el acceso a vectores se realiza utilizando un índice variable. En la siguiente transparencia se muestra un ejemplo para ilustrar este tipo de accesos.

14 Acceso a memoria. Ejemplos Cómo se traduce en ensamblador la expresión en C? int a, b, V[40], i; a = b + V[i]; Se realiza la asignación de registros: a->s0, b->s1, V->s2, i->s3. add $t1, $s3, $s3 # t1 = 2*i add $t1, $t1, $t1 # t1 = 4*i add $t1, $t1, $s2 # t1 = dir. de V[i] lw $t0, 0($t1) # t0 se carga con V[i] add $s0, $s1, $t0 # se realiza la operación Estructura de Computadores Capítulo 3b: Programación en ensamblador del MIPS. p. 15 En este ejemplo, al ser el índice variable, no podemos multiplicarlo nosotros a mano como hemos hecho en los ejemplos anteriores cuando el índice era constante. No obstante el MIPS tiene instrucciones que nos permiten hacer dicha multiplicación fácilmente. Sin embargo, como no hemos visto aún la instrucción de multiplicación, realizaremos la multiplicación por 4 mediante dos sumas: En primer lugar calcularemos i + i = 2i y luego 2i + 2i = 4i. De esto se encargan las dos primeras instrucciones de ensamblador, guardando 4i en el registro t1. Ahora bien, este valor no puede ser usado como desplazamiento en una instrucción de carga o almacenamiento del MIPS, ya que estas instrucciones sólo admiten un desplazamiento constante. No obstante la suma del desplazamiento con el registro base se puede realizar mediante otra instrucción add para así calcular la dirección de V[i]. De esto se encarga la tercera instrucción del programa, almacenando dicha dirección en el registro t1. En este momento ya se puede cargar el valor del elemento del vector V[i] mediante la instrucción lw. Nótese que, como el registro t1 ya contiene la dirección de V[i], se ha utilizado un desplazamiento de 0 en la instrucción de carga. Una vez cargado el elemento del vector en el registro t0 ya solo hace falta realizar la operación de suma, de lo que se encarga la última instrucción. Ejercicio 1. Traduzca a ensamblador el siguiente código en C: int a, b, V[40], i; V[i+1] = b + V[i]; V[i-1] = a + V[i];

15 Codificación en lenguaje máquina Dentro del ordenador sólo hay 0 s y 1 s. Las instrucciones han de codificarse en binario. Por ejemplo: add $t0, $s1, $s2 Se traduce en una secuencia de 32 1 s y 0 s: La representación binaria está dividida en campos para simplificar su decodificación en el hardware. Estructura de Computadores Capítulo 3b: Programación en ensamblador del MIPS. p. 16 Los programas se escriben en lenguaje ensamblador, pero no hay que olvidar que este lenguaje no es más que una representación más amigable de la única representación que entiende el procesador: el lenguaje máquina. Así, antes de poder ejecutar un programa es necesario traducir cada instrucción de lenguaje ensamblador en su instrucción correspondiente de lenguaje máquina. Este proceso no es muy complicado, según se verá más adelante, ya que para simplificar el hardware esta representación binaria se divide en campos dentro de los cuales se codifica cada una de las partes de la instrucción: código de operación, registros... En las siguientes transparencias se muestra en detalle cómo es la codificación de instrucciones en la arquitectura MIPS.

16 Codificación en lenguaje máquina add $t0, $s1, $s2 Operación Destino Fuente 1 Fuente 2 Operación Fuente 2 no usado Fuente 1 Destino Tipo R 6 bits 5 bits 5 bits 5 bits 5 bits 6 bits op rs rt rd shamtfunct Estructura de Computadores Capítulo 3b: Programación en ensamblador del MIPS. p. 17 InstrucioMichaelG.WPg15ComputerAchiExample En la transparencia se muestra la codificación de la instrucción: add $t0, $s1, $s2 Como se dijo en el tema anterior, las instrucciones aritméticas del MIPS que operan sólo con registros se codifican en el formato tipo R. Dicho formato comienza con el campo del código de operación (op) de 6 bits, que en el caso de las instrucciones del tipo R es siempre 0. A continuación viene un campo de 5 bits (rs) en donde se codifica el número del primer registro fuente. En este caso el registro fuente es s1, que según se vio en la página 6 es el registro número 17. En el siguiente campo (rt) se codifica el número del otro registro fuente, que en este caso es número 18 (s2). En el siguiente campo (rd), también de 5 bits, se codifica el registro destino, 8 en este caso (t0, según se puede ver en la página 5). El siguiente campo (shamt) no se usa en esta instrucción y por tanto se deja a 0. El último campo (funct) es una extensión del código de operación. Este último campo especifica qué instrucción particular de todas las del tipo R se ha de ejecutar. La operación suma se codifica con el número 32. Nótese que el orden de los registros fuente y destino es distinto en lenguaje ensamblador que en lenguaje máquina. Las instrucciones de carga y almacenamiento necesitan especificar dos registros y una constante. En una primera aproximación al problema podría pensarse en utilizar uno de los campos reservados para registros (por ejemplo el rt) para almacenar la constante en lugar del número de registro). No obstante con 5 bits sólo se pueden representar números en el rango 0 a 32 o -16 a 15 si se trabaja en complemento a 2. Obviamente los vectores y las estructuras de datos usados en los programas suelen ser mayores de 32 bytes, por lo que esta solución no es muy eficaz. Es preciso por tanto usar otro formato de instrucción para las instrucciones de carga y almacenamiento que permita especificar una constante con un mayor número de bits.

17 Codificación en lenguaje máquina lw $t0, 32($s2) Operación Destino Despl. R. Base Operación Destino Fuente Tipo I 6 bits 5 bits 5 bits 16 bits op rs rt Inmediato Estructura de Computadores Capítulo 3b: Programación en ensamblador del MIPS. p. 18 InstrucioMichaelG.WPg15ComputerAchiExample En la transparencia se muestra la codificación de la instrucción: lw $t0, 32($s2) Como esta instrucción necesita una constante para especificar el desplazamiento, ha de codificarse con el formato tipo I. Como se puede apreciar en la figura, dicho formato es muy similar al formato de las instrucciones de tipo R. La única diferencia consiste en que los tres últimos campos del tipo R (rd, shamt y funct) se han unido en un sólo campo de 16 bits (Inmediato). El hecho de que los formatos sean similares simplifica la decodificación de las distintas instrucciones. El significado de los dos primeros campos es igual al de las instrucciones de tipo R: el primer campo de 6 bits especifica el código de operación (35 para la instrucción lw) y el segundo campo especifica el número del registro base para el acceso a memoria (18 en este ejemplo, que se corresponde con el registro s2). El tercer campo especifica un registro, pero al contrario que en las instrucciones de tipo R, este registro es el destino de la operación. En este ejemplo, el valor leído de la memoria (en la dirección (s2) + 32 ) se escribe en el registro número 8 (t0). Como se puede apreciar, la solución adoptada va contra el primer principio de diseño (la uniformidad simplifica el hardware), ya que en lugar de tener un formato de instrucción fijo se tienen formatos distintos en función del tipo de instrucción. Esto conduce a otro principio de diseño hardware: Principio de diseño 2: un buen diseño necesita buenas soluciones de compromiso. Obviamente, la solución adoptada en este caso complica el hardware al tener que decidir entre distintos modos de decodificación en función del tipo de instrucción (lo cual, recuerde, viene marcado por el valor del código de operación). No obstante, con el fin de simplificar

18 la circuitería al máximo, los distintos formatos se han mantenido lo más parecidos posibles. En este caso, según se ha comentado antes, los tres primeros campos son iguales a los de las instrucciones de tipo R Codificación en lenguaje máquina. Ej. Cómo es el código máquina de la expresión en C? int a, V[400]; V[300] = V[300] + a; Si se realiza la asignación de registros: a->s0, V->s1. Inmediato op rs st rd shamt funct lw $t0, 1200($s1) add $t0, $t0, $s sw $t0, 1200($s1) Estructura de Computadores Capítulo 3b: Programación en ensamblador del MIPS. p. 19

19 En la transparencia se muestra la traducción a código máquina de una sentencia sencilla en C: int a, V[400]; V[300] = V[300] + a; La primera instrucción contiene un 35 como código de operación (lw) seguido de un 17 para identificar el registro base (s1), un 8 para indicar el registro destino (t0) y un 1200 para seleccionar un desplazamiento de 300 palabras (300 pal 4 Byte/pal = 1200 Bytes). De la misma manera, la instrucción siguiente (add) se codifica con un 0 en el campo de código de operación y un 32 en el último campo (funct). El segundo y tercer campo identifican los registros fuente (t0 y s0) y el cuarto campo indica el registro destino (t0). El penúltimo campo no se usa en esta instrucción y por eso se deja a 0. Por último, nótese que la tercera instrucción es similar a la primera: se guarda el contenido del registro en la posición de memoria en lugar de leerlo. Por tanto, lo único que varía es el código de operación (43 en lugar de 35), siendo el resto de campos idénticos a los de la primera instrucción. En la siguiente transparencia se muestra la codificación en binario, que es la que ve realmente el procesador. Codificación en lenguaje máquina. Ej. La codificación en binario es: Inmediato op rs st rd shamt funct La única diferencia entre la 1 a y la 3 a instrucción es el tercer bit. Estructura de Computadores Capítulo 3b: Programación en ensamblador del MIPS. p. 20

20 En la transparencia se muestra la codificación de las instrucciones en binario, que es el formato en el que las ve el procesador. No obstante esta notación es muy oscura para los programadores, por lo que no se usa en la práctica. Se ha usado aquí simplemente con fines ilustrativos. Nótese que para simplificar la decodificación, instrucciones similares se codifican de forma similar. En este caso la diferencia entre la 1 a y la 3 a instrucción consiste solamente en el tercer bit empezando por la izquierda (bit 29 de la palabra). Por último, es necesario resaltar que las instrucciones de un programa no son más que una secuencia de números. Así, el código anterior no son más que tres números binarios de 32 bits. En concreto: Por tanto las instrucciones se pueden almacenar en la memoria al igual que los datos. Esta es una de las ideas fundamentales de la informática y es precisamente lo que hace que los ordenadores sean unas máquinas tremendamente flexibles: basta con cambiar el programa para que un ordenador pase a realizar una tarea totalmente distinta. Toma de decisiones La toma de decisiones es lo que distingue a un ordenador de una calculadora. Permite ejecutar distintas instrucciones en función de datos de entrada o resultados de cálculos. En MIPS se incluyen 2 instrucciones para toma de decisiones: beq reg1, reg2, L1 bne reg1, reg2, L1 Estructura de Computadores Capítulo 3b: Programación en ensamblador del MIPS. p. 21

21 La posibilidad de tomar decisiones en función de los datos de entrada o del resultado de un cálculo es lo que distingue a un ordenador de una simple calculadora. Por ello todos los procesadores incluyen instrucciones que permitan ejecutar una serie de instrucciones u otras en función de un resultado lógico. Esta toma de decisiones se representa en los lenguajes de programación mediante la sentencia if. La arquitectura MIPS incluye dos instrucciones que permiten tomar decisiones en función de los valores almacenados en dos de sus registros: beq reg1, reg2, L1. Esta instrucción compara los contenidos de los registros reg1 y reg2. Si son iguales, el programa salta a la instrucción etiquetada con L1. Si son distintos, el programa continúa en la instrucción siguiente (a beq). El nemónico beq viene de branch if equal. bne reg1, reg2, L1. Al igual que la instrucción anterior, esta instrucción compara los contenidos de los registros reg1 y reg2. Si son distintos, el programa salta a la instrucción etiquetada con L1. Si son iguales, el programa continúa en la instrucción siguiente. El nemónico bne viene de branch if not equal. Debido a su modo de funcionamiento, este tipo de instrucciones se conocen como saltos condicionales. El equivalente en C de ambas instrucciones es, respectivamente: if(i==j) goto L1; if(i!=j) goto L1; En donde se ha supuesto que las variables i y j están almacenadas en los registros Reg1 y Reg2. Toma de decisiones. Ejemplo Cómo se traduce en ensamblador la expresión en C? int a, b, c, i, j; if(i == j) goto L1; b = b + c; L1: a = b - c; Si las variables a-j se asignan a los registros s0-s4. beq $s3, $s4, L1 # Si i==j ir a L1 add $s1, $s1, $s2 # se ejecuta si i!=j L1: sub $s0, $s1, $s2 # se ejecuta siempre Estructura de Computadores Capítulo 3b: Programación en ensamblador del MIPS. p. 22

22 En el fragmento de código C mostrado, se realiza un salto a la instrucción etiquetada con L1 sólo si las variables i y j son iguales. Por tanto, la instrucción b = b + c sólo se ejecutará si i!=j y la instrucción a = b - c se ejecutará siempre. Nótese que este ejemplo es muy artificial, ya que sólo persigue ilustrar las instrucciones de salto condicional de la arquitectura MIPS. De hecho, la mayoría de los programadores evita el uso de sentencias goto en sus programas. En el siguiente ejemplo se mostrará cómo codificar la sentencia if-then-else, que es la que se usa normalmente. La traducción a ensamblador es directa. La sentencia if se traduce por: beq $s3, $s4, L1 # Si i==j ir a L1 En donde la etiqueta L1, al igual que en C, identifica la instrucción a la que es necesario saltar si la condición es cierta. La siguiente sentencia también equivale a una sola instrucción: add $s1, $s1, $s2 # se ejecuta si i!=j La última sentencia en C también se traduce por una sola instrucción en ensamblador, sólo que ahora es necesario incluir la etiqueta de forma que la instrucción de salto condicional pueda saltar a ella cuando la comparación sea cierta. Para ello basta con añadir el nombre de la etiqueta terminado con el carácter : delante de la instrucción: L1: sub $s0, $s1, $s2 # se ejecuta siempre De este modo el ensamblador hace corresponder la etiqueta L1 con la dirección de la instrucción sub $s0, $s1, $s2. Cuando éste traduzca la primera instrucción a lenguaje máquina, la etiqueta L1 será sustituida por la dirección de la tercera instrucción. Por tanto el ensamblador está liberando al programador de otra tarea muy tediosa y propensa a errores: el cálculo de las direcciones de salto. 22-2

23 Toma de decisiones. Ejemplo int a, b, c, i, j; if(i == j){ a = b + c; }else{ a = b - c; } Se traduce en (a-j se asignan a los registros s0-s4): bne $s3, $s4, SiNo # Si i!=j ir a SiNo add $s0, $s1, $s2 # se evita si i!=j j Fin # Salta a Fin SiNo: sub $s0, $s1, $s2 # se ejecuta si i!=j Fin: Estructura de Computadores Capítulo 3b: Programación en ensamblador del MIPS. p. 23 En la transparencia se muestra cómo se traduce una sentencia if-else a ensamblador MIPS. En primer lugar, al igual que en el ejemplo anterior, la sentencia if se traduce por una instrucción de salto condicional. Sin embargo, ahora se comprueba la condición contraria para saltar al bloque else si la condición del if es falsa: bne $s3, $s4, SiNo # Si i!=j ir a SiNo La siguiente sentencia de C, al tener todos sus operandos situados en registros se traduce por una sola instrucción de ensamblador: add $s0, $s1, $s2 # se evita si i!=j Una vez ejecutada esta instrucción, es necesario que el programa continúe después de la sentencia if. Para ello es necesario introducir una nueva instrucción del ensamblador MIPS: el salto incondicional. Esta instrucción se identifica mediante el nemónico j (de jump). Su formato es simplemente j Etiqueta. En este caso: j Fin # Salta a Fin Esta instrucción hace que el procesador salte siempre a la instrucción marcada por la etiqueta Fin. A continuación se sitúa el resultado de traducir la sentencia del else del programa en C. Al igual que antes, esta sentencia se traduce a una sola instrucción aritmética. No obstante, es necesario preceder dicha instrucción por la etiqueta SiNo, ya que esta instrucción es el destino del salto de la comaración: SiNo: sub $s0, $s1, $s2 # se ejecuta si i!=j Por último, es necesario incluir la etiqueta Fin, que es el destino del salto incondicional

24 al final de la sentencia if. Dicha etiqueta representará la dirección de la instrucción siguiente, que no se ha mostrado en la transparencia para simplificar. Por ejemplo, si la siguiente instrucción del programa en ensamblador fuese add $t0, $t0, $t1, entonces el final del programa anterior sería: Fin: add $t0, $t0, $t1 Nótese que no es necesario que la etiqueta esté en la misma línea que la instrucción. Únicamente ha de escribirse antes de ella. Ejercicios 1. Traduzca a ensamblador el ejemplo mostrado en la transparencia usando la instrucción beq para realizar la comparación entre i y j. 2. Traduzca a ensamblador el siguiente código en C: int a, b, c, i, j; if(i == j){ a = b + c; }

25 Toma de decisiones. Bucles int a, V[100], i, j, k; Bucle: a = a + V[i]; i = i + j; if( i!= k) goto Bucle; Se traduce en (a-k se asignan a los registros s0-s4): Bucle: add $t1, $s2, $s2 # t1 = 2i add $t1, $t1, $t1 # t1 = 4i add $t1, $t1, $s1 # t1 = dir. de V[i] lw $t0, 0($t1) # t0 = V[i] add $s0, $s0, $t0 # a = a + V[i] add $s2, $s2, $s3 # i = i + j bne $s2, $s4, Bucle # si i!=k salta Estructura de Computadores Capítulo 3b: Programación en ensamblador del MIPS. p. 24 Al igual que se hizo con el ejemplo del if, esta forma de escribir un bucle en C no es la más común. Es más, no es nada recomendable su uso. Sin embargo, su traducción a ensamblador es directa y por ello se ha usado en este primer ejemplo. En la siguiente transparencia se mostrará cómo se traduce un bucle while a ensamblador MIPS. El programa en C repite las dos primeras instrucciones mientras i!=k. La primera instrucción contiene un acceso a un vector. Por lo tanto es necesario multiplicar por 4 el índice i (s2), de lo que se encargan las dos primeras instrucciones. La tercera instrucción calcula la dirección del elemento del vector y por último la cuarta lo carga en el registro t0. La siguiente instrucción calcula a = a + V[i] y la sexta i = i + j. La última instrucción saltará al principio del bucle si se cumple la condición i!=k. En caso contrario el programa continuará en la instrucción que sigue a bne, terminándose así el bucle. Ejercicio Modifique el programa anterior para evitar el cálculo de 4*i en cada iteración del bucle. Cuantas instrucciones se repiten ahora en cada iteración? Suponiendo que todas las instrucciones tardan lo mismo en ejecutarse, Cual será la mejora en el tiempo de ejecución de un programa que repita este bucle 10 veces?

26 Toma de decisiones. Bucles int a, V[100], i, j, k; while(v[i] == k){ i = i + j; } Se traduce en (a-k se asignan a los registros s0-s4): Bucle: add $t1, $s2, $s2 # t1 = 2i add $t1, $t1, $t1 # t1 = 4i add $t1, $t1, $s1 # t1 = dir. de V[i] lw $t0, 0($t1) # t0 = V[i] bne $t0, $s4, Fin # si i!=k salta add $s2, $s2, $s3 # i = i + j j Bucle Fin: Estructura de Computadores Capítulo 3b: Programación en ensamblador del MIPS. p. 25 En esta transparencia se muestra la traducción a ensamblador de un bucle while en C. Como se puede apreciar, aunque este bucle es más fácil de usar que el anterior, su traducción a ensamblador es un poco más compleja. Afortunadamente este trabajo extra de traducción lo realiza normalmente el compilador. Las 4 primeras instrucciones son las mismas que en el ejemplo anterior, ya que lo primero que hay que hacer es cargar el valor V[i] desde la memoria al registro t0. Una vez cargado dicho valor, se puede evaluar la condición del bucle while. Esto se realiza en la 5 a instrucción. En ella se compara el valor de V[i] (t0) con el valor de k (s4). Si son distintos se salta a la etiqueta Fin, terminándose así el bucle. Si son iguales, se continuará ejecutando la siguiente instrucción para realizar la suma i = i+j, es decir, se ejecuta el cuerpo del bucle. Una vez realizada la suma se salta al principio del bucle mediante un salto incondicional. Nótese que en la instrucción de comparación se ha cambiado la condición que aparece en el código C para conseguir un código más compacto. Ejercicio Traduzca el bucle while anterior a ensamblador MIPS pero utilizando la instrucción beq en lugar de la instrucción bne.

27 Toma de decisiones. Menor que Las comparaciones más habituales en los programas son la igualdad y la desigualdad. Es necesario también saber si una variable es menor que otra. Para ello MIPS define la instrucción slt (set on less than). Por ejemplo: la instrucción slt $t0, $s3, $s4 Pone a 1 t0 si s3 es menor que s4. Si no t0 se pone a 0. Combinando slt, bne, beq y el registro zero se pueden realizar todas las comparaciones. Estructura de Computadores Capítulo 3b: Programación en ensamblador del MIPS. p. 26 Aunque las comparaciones más habituales en los programas son la igualdad y la desigualdad, en muchas ocasiones es necesario saber si el valor de una variable es menor que otra. Por ejemplo en un bucle for que recorre un vector es muy frecuente comparar si el índice es menor que la dimensión del vector. Para realizar este tipo de comparaciones, la arquitectura MIPS define la instrucción slt (de set on less than). Dicha instrucción consta de tres argumentos, un registro destino y dos registros fuente: slt destino, fuente1, fuente2 Su funcionamiento consiste en comparar si el contenido del registro fuente1 es menor que el del registro fuente2. En caso afirmativo escribe un 1 en el registro destino y en caso negativo escribe un 0. En la siguiente transparencia se muestra un ejemplo del uso de esta instrucción para traducir una sentencia if a ensamblador. Ejercicio Los compiladores del MIPS utilizan las instrucciones slt, bne, beq y el valor cero (almacenado en el registro zero) para realizar todas las comparaciones posibles (==,!=, <, >, <= y >=). Escriba las secuencias de instrucciones MIPS que permiten evaluar dichas condiciones entre los registros s0 y s1 y saltar a la etiqueta Fin si el resultado de la comparación es cierto. Por ejemplo, para evaluar la condición s0 > s1 se escribiría: slt $t0, $s1, Ss0 bne $t0, $zero, Fin

28 Toma de decisiones. Ejemplo int a, b, c, i, j; if(i >= j){ a = b + c; } Se traduce en (a-j se asignan a los registros s0-s4): slt $t0, $s3, $s4 # evalúa i < j bne $t0, $zero, Fin # si i<j salta add $s0, $s1, $s2 # a = b + c Fin: Estructura de Computadores Capítulo 3b: Programación en ensamblador del MIPS. p. 27 En el ejemplo mostrado se ha traducido una sentencia if a ensamblador. Como se puede apreciar, para conseguir un código más compacto se ha invertido la condición del if, es decir, en lugar de evaluar la condición i >= j, se ha evaluado la contraria (i < j) para saltarse el cuerpo del if si dicha condición contraria es cierta. En este caso la evaluación de la condición y el salto se realizan en dos pasos. En primer lugar con la instrucción: slt $t0, $s3, $s4 # evalúa i < j Se evalúa la condición i < j y se actualiza el valor del registro t0 con el resultado de la comparación. A continuación, mediante una instrucción de salto condicional se salta al final del if si el resultado de la comparación anterior ha sido cierto: bne $t0, $zero, Fin # si i<j salta Puede parecer extraño a primera vista que la arquitectura MIPS no incluya una instrucción llamada blt (branch on less than). La razón de no incluir dicha instrucción es debido a que, siguiendo la filosofía RISC, no es conveniente implantar instrucciones complicadas o que requieran más de un ciclo de reloj para ejecutarse. Por ello, debido a que comparar si dos valores son menores toma más tiempo que comparar si son iguales, resulta que no es posible implantar la instrucción blt de forma que se ejecute en un ciclo de reloj y por ello los diseñadores del MIPS optaron por implantar dos instrucciones más simples y rápidas.

29 Llamadas a funciones Las funciones permiten programas estructurados, reutilizar código, etc. Dos aspectos importantes: Tienen un interfaz bien definido: Parámetros de entrada y resultados de salida. Realizan su trabajo sin interferir con la función que las llama. Estructura de Computadores Capítulo 3b: Programación en ensamblador del MIPS. p. 28 En cualquier programa, salvo que éste sea extremadamente simple, es necesario usar funciones. El uso de funciones presenta numerosas ventajas, entre las que destacan la mejora de la legibilidad del programa, la posibilidad de reutilizar código, el facilitar la programación al permitir dividir un problema complejo en varios subproblemas más fáciles de abordar, etc. Aunque ya debe de estar familiarizado con el uso de funciones en lenguajes de alto nivel, conviene recalcar dos aspectos de su uso: Constan de un interfaz bien definido con el resto del programa. Reciben una serie de argumentos con los que realiza su tarea y devuelven el resultado de ésta a quien la ha llamado. Son capaces de realizar su tarea sin interferir con el resto del programa. Esto se consigue mediante un espacio de trabajo propio aislado del resto del programa. Así, las variables que utiliza son locales a la función y no son accesibles desde fuera de ella. De la misma forma, la función no puede acceder a las variables locales de las demás funciones.

30 Llamadas a funciones Para poder ejecutar una función es necesario: 1. Situar los parámetros donde la función llamada pueda leerlos. a0-a3, pila 2. Transferir el control a la función llamada. 3. Reservar espacio para las variables locales. t0-t9, pila. 4. Realizar la tarea necesaria. 5. Situar el resultado donde la función llamante pueda leerlos. v0-v1, pila 6. Devolver el control a la función llamante. Estructura de Computadores Capítulo 3b: Programación en ensamblador del MIPS. p. 29 En la transparencia se muestran los distintos pasos que es necesario realizar en la llamada a una función. Tanto el envío de argumentos (paso 1) como la reserva de espacio para las variables locales (paso 3) y la recepción de los resultados (paso 5) son tarea del programador (o del compilador si se programa en un lenguaje de alto nivel). Ahora bien, todo ello se realiza siguiendo una convención software para que todas las funciones puedan interactuar sin problemas, independientemente de su autor y del lenguaje en que hayan sido escritas. En el caso del MIPS, con el objetivo de conseguir mejores prestaciones, se reservan 4 registros (a0-a3) para enviar argumentos a la función y 2 registros (v0-v1) para que la función devuelva su resultado. Si se necesita enviar a la función un número mayor de argumentos o datos que no puedan ser almacenados en registros, entonces es necesario recurrir a la pila. De la misma forma, si la función ha de devolver algún dato que no quepa en los registros (v0-v1), como por ejemplo una estructura de datos, será necesario recurrir a la pila. Las variables locales se pueden almacenar en los registros reservados para valores temporales (t0-t9) o en la pila. En caso necesario se pueden usar también los registros (s0-s7), aunque antes de escribir nada en ellos será necesario guardar su valor en la pila y restaurarlos justo antes de devolver el control a la función llamante, pues dicha función supone que la función llamada dejará estos registros intactos. En otras arquitecturas (p. ej. IA-32) debido al escaso número de registros disponible (8) no se reservan registros para el paso de argumentos ni para valores temporales, siendo entonces necesario un uso intensivo de la pila. El último aspecto de la llamada a una función (paso 6) es la continuación de la ejecución de la función llamante justo en la instrucción siguiente a la usada para realizar la llamada a la función (paso 2). Para ello es necesario guardar la dirección de dicha instrucción siguiente en algún sitio, lo cual necesita que el procesador incluya hardware específico para dicha tarea.

31 En la siguiente transparencia se discute la solución adoptada por los arquitectos del MIPS Llamadas a funciones. Instrucción jal Al transferir el control a la función es necesario guardar la dirección de retorno. En el MIPS esta tarea la realiza la instrucción jal (jump and link) Formato: jal Dir_de_la_función Funcionamiento: Guarda la dirección de retorno (PC+4) en el registro ra. Salta a la dirección Dir_de_la_función. Estructura de Computadores Capítulo 3b: Programación en ensamblador del MIPS. p. 30

32 La instrucción jal (del inglés jump and link, saltar y enlazar) permite saltar a la dirección de su argumento (jump) y a la vez almacenar la dirección de la instrucción de retorno (link), que será la instrucción que esté situada a continuación de jal. Dicha dirección será obviamente PC+4. El lugar elegido por los arquitectos del MIPS para almacenar la dirección de retorno es un registro reservado para este fin, denominado ra (del inglés return address, dirección de retorno). Esto permite que la ejecución de la instrucción se realice en un solo ciclo de reloj. Las arquitecturas CISC guardan la dirección de retorno en la pila, aunque esto conlleva un tiempo de ejecución mayor, pues hace falta hacer un acceso adicional a la memoria para guardar la dirección de retorno. Por ejemplo, si se desea saltar a la función llamada fun bastará con escribir: jal fun Además de esto, es necesario que la primera instrucción de la función tenga como etiqueta fun: fun: add $t0, $a0, $a1... Llamadas a funciones. Instrucción jr Para volver de una función es necesario saltar a la dirección almacenada en ra En el MIPS esta tarea se realiza con la instrucción jr (jump register). Formato: jr registro Funcionamiento: Salta a la dirección almacenada en el registro. Por tanto, el retorno de la función se realiza con: jr $ra Estructura de Computadores Capítulo 3b: Programación en ensamblador del MIPS. p. 31

33 Por último, una vez finalizada su tarea, la función ha de colocar el resultado en los registros v0-v1 o la pila y devolver el control a la función que la ha llamado. Como la llamada a la función mediante la instrucción jal guarda la dirección de la instrucción que le sigue en el registro ra, basta con saltar a la dirección almacenada en dicho registro. Para ello, el MIPS dispone de una instrucción que permite saltar incondicionalmente a la dirección almacenada en un registro, llamada jr (del ingles jump register, saltar registro). Por tanto, la última instrucción de la función será precisamente: jr $ra Resumiendo, la función llamante coloca los argumentos en los registros a0-a3 y mediante la instrucción jal fun llama a la función fun. Dicha función realiza su tarea y deposita sus resultados en los registros v0-v1 para a continuación devolver el control a la función llamante mediante la instrucción jr $ra. En la siguiente transparencia se muestra un ejemplo para aclarar el proceso. Llamadas a funciones. Ejemplo int funhoja(int g, int h, int i, int j) { int f; f = (g + h) - (i + j); return f; } Se traduce en (g-j se pasan en los registros a0-a3): funhoja: add $t0, $a0, $a1 # t0 = g + h add $t1, $a2, $a3 # t1 = i + j sub $t0, $t0, $t1 # t0 = (g+h) - (i+j) add $v0, $t0, $zero # v0 = t0 jr $ra Estructura de Computadores Capítulo 3b: Programación en ensamblador del MIPS. p. 32

34 En la transparencia se muestra un ejemplo de traducción a ensamblador de una función muy simple escrita en C. Como se puede apreciar en primer lugar, dicha función no llama a ninguna otra. A este tipo de funciones se les denomina funciones hoja. Además, dicha función sólo necesita 4 argumentos, por lo que no es necesario recurrir a la pila. De la misma forma, como la función devuelve un valor entero, basta con un sólo registro para ello (v0). Como se puede observar, la función sólo necesita almacenar dos valores en variables locales (los resultados parciales de sus cálculos), por lo que basta con usar dos de los 10 registros temporales disponibles (t0 y t1). Una vez terminados sus cálculos, la función ha de copiar el resultado obtenido al registro v0 para devolverlo a la función llamante. En MIPS no existe una instrucción específica para mover datos entre registros, aunque dicho movimiento se puede realizar sumándole cero al registro origen y usando el registro destino como resultado de la suma. Así, lo que en otras arquitecturas se escribiría como: move $v0, $t0 En MIPS se escribe como: add $v0, $t0, $zero Ejercicio La codificación de la función anterior dista bastante de ser la óptima, tanto en uso de registros como en número de instrucciones. Escriba otra versión de la función más eficiente. Llamadas a funciones. La pila En algunas arquitecturas existen instrucciones explícitas para el manejo de la pila (push y pop). El MIPS no tiene soporte explícito de la pila sino una convención software: Se reserva el registro sp (stack pointer) para apuntar al tope de la pila. La pila crece hacia abajo. sp sp Contenido ra Contenido a0 sp Estructura de Computadores Capítulo 3b: Programación en ensamblador del MIPS. p. 33

35 Como se ha comentado antes, el uso de la pila es imprescindible en la llamada a las funciones. Esto es debido a que sólo es necesario conocer el orden en que se han almacenado los datos, no su posición absoluta y además puede crecer indefinidamente ; permitiéndose así el anidamiento de varias funciones sin que los datos de éstas interfieran entre sí. Aunque muchos procesadores incluyen instrucciones específicas para el manejo de la pila (push y pop), el MIPS no dispone de ellas. No obstante existe una convención software para implantar una pila: Se reserva el registro sp (del inglés stack pointer, puntero de pila) para apuntar al tope de la pila. Es responsabilidad del programador el manejo de este registro, es decir, si se introduce o se retira un dato en la pila, habrá que modificar el sp para que continúe apuntando al tope de la pila. La pila crece desde posiciones altas de memoria hacia posiciones bajas. No hay ninguna razón para hacerlo así salvo por los precedentes históricos. En consecuencia el tope de la pila será la dirección más baja de ésta. En la figura de la transparencia se ilustra la evolución de la pila cuando se llama a una función que necesita guardar dos registros (ra y a0) en la pila. Como se puede apreciar en primer lugar (figura izquierda) el registro sp estará apuntando al último dato introducido en la pila (no mostrado por simplificar). Cuando se llama a la función, ésta necesita guardar en la pila dos registros, por lo que el sp se decrementa en dos palabras (8 bytes) y en el espacio creado se copiará el contenido de los dos registros (ra y a0) (figura central). Una vez finalizada la función, la pila ha de quedar como estaba, tal como se muestra en la figura de la derecha. Llamadas a funciones. Anidamientos En el ejemplo anterior se mostró una función hoja. Lamentablemente hay funciones que llaman a otras funciones. En estos casos es necesario: Guardar la dirección de retorno ra Guardar los registros (a0-a3 y t0-t9) que se necesiten después. Obviamente estos registros se guardan en la pila. Estructura de Computadores Capítulo 3b: Programación en ensamblador del MIPS. p. 34

36 En el ejemplo mostrado anteriormente, la función era una función hoja, es decir, la función no llamaba a ninguna otra función. Desgraciadamente, no todas las funciones son funciones hoja, por lo que el mecanismo de llamada se complica un poco en estos casos. En concreto, la función llamante ha de guardar los registros que la función llamada pueda modificar: El primer registro que se modifica es el registro de la dirección de retorno ra, ya que en cuanto se ejecute la instrucción jal dicho registro se sobreescribirá con la nueva dirección de retorno. Por tanto, antes de llamar a una función es necesario guardar el valor de ra en la pila. Si la función necesita algún argumento, este ha de copiarse en los registros a0-a3. Por tanto, si la función llamante ha de usar algún valor de estos registros después de la llamada a la función, ha de guardar éstos en la pila. Nótese que aunque no se necesite usar alguno de los registros a0-a3 para pasar argumentos a la función, ésta puede llamar a otra función que necesite ese registro como argumento. Por tanto, siempre se guardarán los registros a0-a3 cuyos valores sean necesarios después de la llamada a una función. Si la función llamante necesita usar algún valor almacenado en los registros temporales t0-t9 después de la llamada a la función, también tendrá que guardarlos en la pila antes de llamarla. El ejemplo más complicado de función no hoja es una función recursiva. En la siguiente transparencia se muestra una función para calcular el factorial de forma recursiva. Aunque este es el peor ejemplo de uso de la recursividad, pues es mucho más eficiente resolverlo con un bucle, su simplicidad justifica su uso en este caso. Llamadas a funciones. Ejemplo int fact(int n) { if (n < 1){ return 1; }else{ return n * fact(n-1); } } Se traduce en (n se pasa en el registro a0): Estructura de Computadores Capítulo 3b: Programación en ensamblador del MIPS. p. 35

37 Llamadas a funciones. Ejemplo fact: slti $t0, $a0, 1 # n<1? beq $t0, $zero, L1 # Si n>=1, a L1 addi $v0, $zero, 1 # devuelve 1 jr $ra L1: addi $sp, $sp, -8 # Reserva 2 palabras en pila sw $ra, 4($sp) # guarda ra y sw $a0, 0($sp) # n en pila addi $a0, $a0, -1 # a0=n-1 jal fact lw $a0, 0($sp) # restaura n lw $ra, 4($sp) # y ra addi $sp, $sp, 8 # ajusta sp mul $v0, $a0, $v0 # devuelve jr $ra # n * fact(n-1) Estructura de Computadores Capítulo 3b: Programación en ensamblador del MIPS. p. 36 Al igual que el programa en C, lo primero que realiza la función es comprobar si su argumento n (a0) es menor que 1 para en caso afirmativo devolver un 1. Para realizar la comparación se ha usado una versión de la instrucción slt denominada slti (del inglés set on less than inmediate). El funcionamiento es idéntico a la instrucción slt salvo que en lugar de comparar dos registros, compara un registro con una constante. Por tanto la instrucción: slti $t0, $a0, 1 # n<1? Compara el registro a0 con la constante 1 y pondrá a uno t0 si (a0) <1. La siguiente instrucción saltará a la etiqueta L1 si el resultado de la comparación anterior fue falso, es decir, si n >= 1. En caso contrario (n<1) se ejecutarán las instrucciones: addi $v0, $zero, 1 # devuelve 1 jr $ra que devuelven 1 a la función llamante. Para ello se ha utilizado una nueva instrucción denominada addi que suma una constante a un registro y almacena el resultado en un tercer registro. En este caso dicha instrucción suma y almacena el resultado en v0. El control se devuelve a continuación mediante la instrucción jr. Nótese que en este caso particular la función fact se comporta como una función hoja, ya que no llama a más funciones. Por tanto no ha sido necesario en este caso guardar ningún registro en la pila. Si n >= 1, entonces es necesario llamar recursivamente a la función fact, aunque antes de ello es necesario guardar en la pila los registros que se vayan a necesitar más tarde. Estos registros son el ra y el a0. El primero es necesario para preservar la dirección de retorno y el segundo para poder usar el valor de n al calcular n * fact(n-1). Para guardar los registros, lo primero que se hace es reservar sitio en la pila, moviendo el puntero 8 bytes (2 palabras) más abajo. A continuación se guarda ra en la segunda palabra y a0 en el tope de la pila: L1: addi $sp, $sp, -8 # Reserva 2 palabras en pila

38 sw $ra, 4($sp) # guarda ra y sw $a0, 0($sp) # n en pila La estructura de la pila en este instante será la mostrada en la figura de la transparencia 33. Una vez salvados los dos registros, se pasa a llamar a la función fact. Para ello, se sitúa en el registro a0 el valor n-1, lo cual se hace restando 1 a dicho registro, ya que éste contenía el valor de n. Una vez hecho esto ya se puede llamar a la función fact mediante la instrucción jal: addi $a0, $a0, -1 # a0=n-1 jal fact Cuando dicha función devuelva el control, en el registro v0 estará almacenado el valor de (n-1)!. Por tanto, lo único que hay que hacer es restaurar los registros que se almacenaron en la pila y calcular n*(n-1)! para devolverlo. La restauración de registros es el proceso inverso al realizado para guardarlos: lw $a0, 0($sp) # restaura n lw $ra, 4($sp) # y ra addi $sp, $sp, 8 # ajusta sp Como se puede apreciar, después de la ejecución de estas instrucciones la pila se quedará como estaba antes de llamar a la función. Lo único que resta por hacer es calcular n*(n-1)! y devolver el control a la función llamante, lo cual se realiza mediante: mult $v0, $a0, $v0 # devuelve jr $ra # n * fact(n-1) Ejercicio Escriba un programa en ensamblador del MIPS para calcular el factorial de 7. Utilice para ello la función fact desarrollada anteriormente. 36-3

39 Llamadas a funciones. Bloque de activación La pila crece y decrece durante la ejecución de la función para: Almacenar variables locales. Evaluar expresiones. Guardar registros. El segmento de la pila que contiene todos los datos de una función se denomina bloque de activación Algunos programas usan el registro fp para apuntar al principio del bloque de activación. Estructura de Computadores Capítulo 3b: Programación en ensamblador del MIPS. p. 37 Durante la ejecución de la función la pila puede crecer y decrecer. Por ejemplo si se declara una estructura como variable local, ésta tendrá que almacenarse en la pila, para lo que será necesario decrementar el sp en el número de palabras que ocupe dicha estructura. Además algunos programas necesitan usar la pila para evaluar expresiones matemáticas complejas. Por si esto fuera poco, algunos lenguajes como C++ permiten crear variables locales en cualquier punto de la función, por lo que la pila puede crecer en cualquier momento. Esto hace que si se usa el registro sp para acceder a las variables almacenadas en la pila, será necesario utilizar desplazamientos distintos a lo largo de la función, dificultándose la escritura del programa. Por tanto, es conveniente tener una referencia a las variables almacenadas en la pila que no varíe durante la ejecución de la función. Algunos programas MIPS usan el registro fp para almacenar la primera palabra del bloque de la pila usado por la función, al que se denomina bloque de activación. Por ello al registro fp se le conoce como puntero al bloque de activación (frame pointer). Dicho registro se carga con el valor del sp al iniciar la función y no varía hasta que ésta termine. Por tanto, los accesos a las variables almacenadas en la pila pueden referirse al fp y dichas referencias no tendrán que cambiarse cada vez que se introduzca o elimine algún dato de la pila. Ejercicio El uso del puntero al bloque de activación facilita además la restauración del puntero de pila al final de la ejecución de la función. Escriba las instrucciones necesarias para guardar el principio del bloque de activación en fp al principio de la función y para restaurar el sp al finalizar la función.

40 Llamadas a funciones. Paso de arg. por pila Si hay más de 4 parámetros o alguno de éstos no cabe en registros se pasan por la pila. Convención software: se sitúan por encima del bloque de activación. fp sp Bloque Activación fp sp Argumentos Bloque Activación fp sp Bloque Activación Estructura de Computadores Capítulo 3b: Programación en ensamblador del MIPS. p. 38 Según se ha dicho anteriormente, hay ocasiones en las cuales los 4 registros reservados para el paso de argumentos entre funciones (a0-a3) no son suficientes: Si hay más de 4 argumentos. En este caso los 4 primeros se pasan en los registros y los restantes en la pila. Si algún o algunos argumentos no caben en un registro. En este caso los argumentos que no quepan se pasan por la pila. En estos casos, los argumentos se sitúan justo encima del bloque de activación de la función llamada (o visto de otra manera, al final del bloque de activación de la función llamante). Para acceder a ellos, lo más conveniente es usar el puntero al bloque de actuvación fp. Ejercicios 1. Escriba la siguiente función en C en ensamblador MIPS: int suma(int a, int b, int c, int d, int e, int f){ return a+b+c+d+e+f; } 2. Escriba la secuencia de intrucciones de ensamblador MIPS para sumar los valores almacenados en los 6 registros s0-s5 mediante una llamada a la función suma. El resultado se guardará en el registro s6.

41 Manejo de caracteres Los caracteres se codifican en ASCII. Un carácter ASCII ocupa 1 byte. El MIPS dispone de dos instrucciones para cargar y almacenar bytes: lb (load byte). Lee un byte de la memoria y lo almacena en los 8 bits menos significativos del registro destino. Ej. lb $t0, 0($s0). sb (store byte). Almacena los 8 bits menos significativos del registro origen en la memoria. Ej. sb $t0, 0($s0). Los caracteres pueden estar en cualquier posición de memoria. Estructura de Computadores Capítulo 3b: Programación en ensamblador del MIPS. p. 39 La mayoría de las aplicaciones informáticas necesitan procesar caracteres. Existen varios métodos de codificación, aunque el más extendido es el ASCII, en el cual un carácter ocupa un byte. El MIPS dispone de dos instrucciones para cargar y almacenar bytes: lb y sb. El funcionamiento de ambas instrucciones es análogo a lw y sw, excepto que sólo leen un byte de la memoria y lo almacenan en los 8 bits menos significativos del registro destino. Además el byte puede estar situado en cualquier posición de memoria.

42 Manejo de caracteres. Ejemplo El siguiente ejemplo muestra la función strcpy de C: void strcpy(char dest[], char orig[]) { int i; i = 0; /*Copia y comprueba final*/ while( (dest[i] = orig[i])!= NULL){ i++; } } Cuál es la traducción a ensamblador MIPS? Estructura de Computadores Capítulo 3b: Programación en ensamblador del MIPS. p. 40 En la transparencia se muestra una implementación de la función strcpy de la librería estándar de C. Dicha función copia una cadena orígen (orig) en otra cadena destino (dest). Ambas cadenas siguen la convención de C para indicar su final mediante el carácter nulo (NULL). La función copia el caracter i de la cadena orígen en la posición i de la cadena destino y despúes comprueba si éste es distinto de NULL. Si no lo es incrementa el índice y continúa el bucle. Cuando el carácter copiado sea el terminador nulo de la cadena, el bucle terminará, aunque después de copiar el NULL a la cadena de destino, con lo que ésta será correcta. En la siguiente transparencia se muestra el código en ensamblador MIPS para implementar esta misma función.

43 Manejo de caracteres. Ejemplo strcpy: add $t0, $zero, $zero # i = 0 L1: add $t1, $t0, $a1 # t1=dir(orig[i]) lb $t2, 0($t1) # t2 = orig[i] add $t3, $t0, $a0 # t3=dir(dest[i]) sb $t2, 0($t3) # dest[i] = t2 add $t0, $t0, 1 # i++ bne $t2, $zero, L1 jr $ra Estructura de Computadores Capítulo 3b: Programación en ensamblador del MIPS. p. 41 La primera instrucción símplemente pone a cero el registro t0, que va a ser usado para almacenar el índice i. Nótese que dicha operación se hace almacenando el resultado de sumar 0+0. La siguiente instrucción calcula la dirección del carácter de la cadena origen que se va a copiar. Para ello se suma el índice i a la base de la cadena, que según puede desprenderse del código en C, estará almacenado en el registro a1, pues es el segundo argumento de la función. Una vez calculada la dirección, se puede usar la instrucción lb para cargar el carácter en el registro t2, que es lo que se hace en la tercera instrucción. A continuación se calcula la dirección en la que hay que almacenar el carácter, que será el resultado de sumar el índice i a la base de la cadena destino (almacenada en a0) y se almacena el carácter en dicha dirección mediante la instrucción sb Por último se incrementa el índice y se salta al principio del bucle si el carácter es distinto de cero (recuerde que en C NULL es un 0). Si se encuentra el terminador nulo de la cadena, no se producirá el salto y se devuelve el control mediante la instrucción jr. Ejercicios 1. Por qué no hace falta multiplicar por 4 el índice de la cadena? 2. La codificación en ensamblador no refleja exáctamente el código C de la función. Por qué? Codifique una función que refleje exáctamente el código C y compare su eficiencia con la mostrada en la transparencia. Indique para ello el número de instrucciones ejecutadas en cada versión de la función si se copia una cadena de 80 caracteres.

44 Aritmética. Números con y sin signo El MIPS trabaja con ristras de 8, 16 o 32 bits. Estas ristras de bits pueden representar, entre otras cosas: Un número sin signo (rango 0 2 n 1). Un número con signo en complemento a 2 (rango 2 n 1 2 n 1 1). Tanto las instrucciones aritméticas como las de carga y comparación han de distinguir si sus operandos son con o sin signo. Estructura de Computadores Capítulo 3b: Programación en ensamblador del MIPS. p. 42 El procesador es una máquina capaz de procesar ristras de dígitos binarios. En el caso del MIPS, éste puede trabajar con ristras de 8, 16 y 32 bits. El significado de dichas ristras de bits es totalmente indiferente para el procesador, 1 siendo responsabilidad del programador su interpretación. Cuando se trabaja con números enteros, éstos pueden considerarse como números sin signo, con lo cual podremos representar números en el rango de 0 a 2 n 1. o bien como números codificados en complemento a dos (rango de 2 n 1 a 2 n 1 1). Ahora bien, la forma de operar con ambos tipos de números es distinta, por lo que se usan instrucciones distintas según el tipo de datos utilizados. Así, las instrucciones aritméticas, de carga y de comparación son distintas según operen con datos sin signo o con signo. En el caso de los lenguajes de alto nivel como C, al declarar una variable se informa al sistema del tipo de ésta. Así, para crear un entero con signo se declara como int y sin signo como unsigned int. Es entonces tarea del compilador elegir las operaciones necesarias para operar correctamente con los datos. En cambio, cuando se programa en ensamblador, esta tarea recae en el programador. 1 Salvo en el caso en que dihas ristras de bits sean parte de un programa.

45 Aritmética. Números con y sin signo Cuando se carga un número con signo de 16 u 8 bits en un registro de 32, es necesario extender el bit de signo. Ej: -1 en 8 bits es en 16 bits es en 32 bits es Esta extensión es necesaria porque los circuitos aritméticos operan sólo con números de 32 bits. Estructura de Computadores Capítulo 3b: Programación en ensamblador del MIPS. p. 43 Aritmética. Números con y sin signo Cuando se carga un número sin signo de 16 u 8 bits en un registro de 32, no hay que extender el bit de signo. Ej: 255 en 8 bits es en 32 bits es Estructura de Computadores Capítulo 3b: Programación en ensamblador del MIPS. p. 44

46 Aritmética. Números con y sin signo Las instrucciones de carga vistas hasta ahora cargan números con signo: lb carga un byte extendiendo el signo. lh carga una media palabra (16 bits) extendiendo el signo. La media palabra ha de estar en una dirección par. lw carga una palabra. No tiene sentido extender el signo, pues no hay más bits. Estructura de Computadores Capítulo 3b: Programación en ensamblador del MIPS. p. 45 Debido a que internamente el MIPS siempre realiza las operaciones con 32 bits, cuando se carga un dato de 8 o 16 bits en un registro, es necesario que la cantidad representada por los 32 bits sea la misma que la representada por los 8 o los 16 bits que se han cargado. Si las cantidades almacenadas en 8 o 16 bits son sin signo, basta con copiar esos 8 o 16 bits en los 8 o 16 bits menos significativos del registro de 32 bits. Ahora bien, si los números de 8 o 16 bits son con signo, es necesario copiar el bit de signo en los bits superiores del registro de 32 bits para que se mantenga el signo del número. Así, si tenemos almacenado en una variable de 8 bits con signo el valor (-2), al copiar dicha variable en un registro de 32 bits, habrá que copiar el bit de signo en los bits 9 a 31 para que el número almacenado en el registro sea también un -2. En cambio, si tenemos almacenado un número sin signo, por ejemplo (254), al copiar este número en un registro de 32 bits no habrá que extender el bit signo para que se almacene el 254 correctamente en el registro de 32 bits. Las instruciones de carga vistas hasta ahora (lb y lw) trabajan con números con signo. En el caso de lw no tiene sentido hacer ninguna distinción, pues carga un número de 32 bits en un registro de 32 bits y por tanto no hay que hacer extensión de signo. Además de estas dos instrucciones de carga existe una tercera lh que carga media palabra (16 bits) en los 16 bits menos significativos de un registro, extendiendo el bit de signo. Por ejemplo, para cargar en t0 una media palabra cuya dirección está almacenada en el registro s0, basta con ejecutar la instrucción: lh $t0, 0($s0) Las medias palabras han de estar alineadas en posiciones de memoria múltiplos de 2.

47 Aritmética. Números con y sin signo Las instrucciones de carga para números sin signo son: lbu carga un byte sin extender el signo. lhu carga una media palabra (16 bits) sin extender el signo. lw carga una palabra. No tiene sentido extender el signo, pues no hay más bits. Estructura de Computadores Capítulo 3b: Programación en ensamblador del MIPS. p. 46 Las instrucciones para cargar números sin signo son iguales que las correspondientes para números con signo, salvo que su nemónico termina en u (de unsigned). Aunque no se menciona en la transparencia, la media palabra a cargar con lhu ha de estar almacenada en una dirección par. Al igual que antes, no tiene sentido distinguir entre números con signo o sin signo para la carga de palabras de 32 bits, pues no hay que extender ningún bit de signo.

48 Aritmética. Números con y sin signo Las instrucciones de comparación son distintas para números con signo o sin signo: slt compara dos números con signo. sltu compara dos números sin signo. slti Compara un registro con una constante. Ambas con signo. sltiu Compara un registro con una constante. Ambas sin signo. Ej: slti $t0, $s0, -7 Estructura de Computadores Capítulo 3b: Programación en ensamblador del MIPS. p. 47 La comparación entre dos números depende de si éstos son con signo o sin signo. Por tanto el MIPS dispone de versiones de las instrucciones de comparación para ambos tipos de datos. Al igual que antes, las instrucciones estudiadas hasta ahora comparan números con signo. Para comparar números sin signo el formato de las instrucciones es el mismo salvo que el nemónico termina en una u (de unsigned).

49 Aritmética. Números con y sin signo Ejemplo: s0 = s1 = Cuanto valen t0 y t1 después de ejecutar las instrucciones? slt $t0, $s0, $s1 # Con signo sltu $t1, $s0, $s1 # Sin signo Estructura de Computadores Capítulo 3b: Programación en ensamblador del MIPS. p. 48 En el ejemplo, el registro s0 vale -1 si se interpreta como un número en complemento a 2 ó si se interpreta como un número sin signo. El registro s1, en cambio, vale 1 independientemente de cómo se interprete. En la primera instrucción se realiza la comparación con signo. Por tanto, como 1 < 1, t0 se pondrá a 1. En cambio, en la segunda instrucción se realiza la comparación sin signo, por lo que como 4,294,967,295 > 1, t1 se pondrá a 0.

50 Aritmética. Suma y resta En las instrucciones de suma y resta puede ser necesario saber si ha existido un desbordamiento. En los números sin signo, utilizados para aritmética de direcciones, se ignora. En los números con signo, dependiendo de la aplicación, puede ser necesario detectarlo. Estructura de Computadores Capítulo 3b: Programación en ensamblador del MIPS. p. 49 Al realizar una suma o una resta de dos números de 32 bits, el resultado puede necesitar 33 bits si ambos números son demasiado grandes. Como el resultado se almacena en un registro de 32 bits, el bit más significativo se pierde. En estos casos se dice que se ha producido un desbordamiento (overflow en inglés). El uso fundamental de los números sin signo es la realización de operaciones con direcciones, en las cuales no se suele detectar el desbordamiento. En cambio, los números con signo suelen usarse en operaciones matemáticas, en las que, dependiendo de la aplicación, puede ser necesario detectar si se ha producido un desbordamiento. La mayoría de los procesadores disponen de dos bits en el registro de estado para indicar si se ha producido un desbordamiento: El bit de accarreo (carry en inglés), el cual se pone a 1 cuando se produce un desbordamiento en la suma sin signo. El bit de desbordamiento (overflow), el cual se pone a 1 cuando se produce un desbordamiento en la suma con signo. En estos procesadores se incluyen además instrucciones de salto condicional que saltan si alguno de estos bits está a 1. Por tanto, para detectar un desbordamiento basta con ejecutar la instrucción de salto condicional justo después de la operación aritmética cuyo desbordamiento queremos comprobar. De esta forma el programa puede ejecutar una serie de isntrucciones u otras en función de si se ha producido o no un desbordamiento. En el MIPS, según se muestra en la siguiente transparencia, la solución adoptada es radicalmente distinta.

51 Aritmética. Suma y resta MIPS dispone de dos tipos de instrucciones para la suma y la resta en función del tratamiento del desbordamiento. add, addi, sub, generan una excepción si se produce un desbordamiento. addu, addiu, subu no generan excepciones en caso de desbordamiento. Las instrucciones de suma se han estudiado antes. La instrucción sub $t0, $s0, $s1 resta s0-s1 y almacena el resultado en t0. Estructura de Computadores Capítulo 3b: Programación en ensamblador del MIPS. p. 50 El MIPS dispone de dos tipos de instrucciones aritméticas: unas que tienen en cuenta el desbordamiento y otras que lo ignoran. Las instrucciones add, addi y sub generan una excepción si se produce un desbordamiento. Una excepción es una llamada a una función no planificada, es decir, que sólo ocurre cuando se da una situación excepcional, como es un desbordamiento en este caso. Así, cuando al ejecutar alguna de estas instrucciones se produce un desbordamiento, la dirección de la instrucción que ha provocado el desbordamiento se sitúa en un registro especial y la ejecución del programa salta a una direción predefinida en la que se encontrará una rutina de atención de la excepción. Esta rutina podrá infomar al usuario del error y abortar el programa o intentar tomar medidas correctoras y continuar el programa después de la instrucción que causó el desbordamiento. Por otro lado, las instrucciones addu, addiu y subu realizan las mismas operaciones que sus versiones con signo salvo que no generan una excepción si se produce un desbordamiento. El formato de la instrucción de resta es sub dest, orig1, orig2. Esta instrucción resta el contenido de los registros orig1-orig2 y deposita el resultado en el registro dest. Nótese que no existe la instrucción subi. Esto es debido a que la instrucción addi suma a un registro una constante de 16 bits con signo, por lo que para restar una constante basta con sumar dicha constante cambiada de signo. Conviene destacar que tanto las instrucciones addi como addiu extienden siempre el signo de su constante de 16 bits antes de realizar la operación. Como se ha dicho antes la única diferencia entre las operaciones sin signo y las con signo es que las primeras no generan excepciones y las segundas sí. Como se ha dicho antes, otras arquitecturas poseen instrucciones de salto condicional en función de si se ha producido o no un desbordamiento. Lamentablemente el MIPS no dispone de dicha instrucción, por lo que si queremos detectar el desbordamiento sin utilizar

52 excepciones, es necesario realizarlo mediante una secuencia de instrucciones, tal como se muestra a continuación 50-2 Aritmética. Suma y resta addu $t0, $t1, $t2 # suma sin desbordamiento xor $t3, $t1, $t2 # signos distintos? slt $t3, $t3, $zero #si t3<0 signos distintos bne $t3, $zero, NoDesb # si signos distintos # => no desb. xor $t3, $t0, $t1 # si signos iguales slt $t3, $t3, $zero # suma también? bne $t3, $zero, Desb # Si sign(suma)!= sign(op) # => desbordamiento Estructura de Computadores Capítulo 3b: Programación en ensamblador del MIPS. p. 51

53 Claramente la comprobación del desbordamiento en el MIPS es realmente compleja. Afortunadamente en la mayoría de los casos no es necesario realizar dicha comprobación de forma explícita. Por ejemplo en C no se tienen en cuenta nunca los desbordamientos para obtener programas más eficientes, aun a costa de que se produzcan resultados erróneos. Otros lenguajes como Fortran o Ada si precisan que se detecten los desbordamientos, pues en las aplicaciones escritas en dichos lenguajes prima mucho más la fiabilidad de los programas que su velocidad de ejecución. No obstante, en estos lenguajes se suele utilizar una rutina de excepción para atender las excepciones numéricas, por lo que la aproximación seguida por el MIPS es apropiada en estos casos. El programa mostrado en la transparencia se basa en verificar en primer lugar si los signos de los dos sumandos son distintos, en cuyo caso nunca se producirá un desbordamiento. Para ello realiza una or exclusiva bit a bit de ambos sumandos con la instrucción MIPS xor. El bit de signo del resultado de la XOR será 1 si los signos de ambos sumandos son distintos y 0 si son iguales. Por tanto, si los signos son distintos, en t3 tendremos un número negativo, por lo que mediante la instrucción de salto condicional se saltará a la etiqueta nodesb. Si ambos números tienen el mismo signo, se puede producir un desbordamiento, en cuyo caso el resultado tendrá distinto signo que los operandos. El resto del programa es similar al anterior, sólo que ahora se comprueba si los signos del resultado y de los sumandos son distintos, en cuyo caso se salta a la etiqueta Desb para ejecutar el tratamiento del desbordamiento. Como se ha comentado antes, en las sumas sin signo no suele ser necesario comprobar el desbordamiento. Por ello el MIPS no generará ninguna excepción en este caso. Si se necesita detectar un desbordamiento, la única manera es usando la secuencia de instrucciones mostradas en la siguiente transparencia. Aritmética. Suma y resta addu $t0, $t1, $t2 # suma sin desbordamiento nor $t3, $t1, $zero # t3 = not(t1) = # C2(t1) - 1 = 2^32 -t1-1 sltu $t3, $t3, $t2 # 2^32 -t1-1 < t2 => # 2^32-1 < t1 + t2 => # desbordamiento. bne $t3, $zero, Desb Estructura de Computadores Capítulo 3b: Programación en ensamblador del MIPS. p. 52

54 En este caso el programa es más corto, aunque más difícil de entender. En primer lugar se invierten todos los bits de t1. Para ello se utiliza la operación nor que calcula una OR negada bit a bit. Esta inversión es equivalente a calcular el complemento a 2-1 (recuerde que el complemento a 2 se calcula invirtiendo todos los bits y sumando 1). Como el complemento a 2 de t1 es t1, el resultado de la operación anterior será t1-1. Si se compara este resultado con t2, tenemos que: (1) 2 32 t1 1 < t < t1 + t2 Por tanto, si el resultado de la comparación es cierto, el resultado de t1+t2 será mayor de y por tanto se necesitarán más de 32 bits para representarlo. En consecuencia, al no caber el resultado en 32 bits se habrá producido un desbordamiento. Aritmética. Multiplicación El MIPS dispone de dos instrucciones para multiplicar: mult (con signo) o multu (sin signo). El resultado se almacena en un registro de 64 bits, accesible en su mitad superior hi y en su mitad inferior lo mediante las instrucciones mfhi y mflo. Ej: mult $s0, $s1 multiplica s0 por s1 Estas instrucciones no detectan desbordamientos. El resultado cabrá en 32 bits si hi vale 0 en multu o la repetición del bit de signo en mult. Estructura de Computadores Capítulo 3b: Programación en ensamblador del MIPS. p. 53

55 En el caso de la multiplicación, el hardware es ligeramente distinto según se multipliquen números con signo o números sin signo (de Miguel Anasagasti, 2000). Debido a esto, el MIPS dispone de dos instrucciones para multiplicar: mult para números con signo y multu para números sin signo. Ambas instrucciones multiplican el contenido de dos registros y almacenan el resultado en un registro de 64 bits. Como el producto de dos números de 32 bits nunca será mayor de 64 bits, no se producirá nunca ningún desbordamiento, por lo que ambas instrucciones de multiplicación no generan excepciones. El registro de 64 bits en donde se almacena el resultado es accesible en sus dos mitades (hi y lo) mediante dos instrucciones especiales. La instrucción mfhi (del inglés move from high) traslada los 32 bits más significativos a un registro destino. De la misma forma, mflo (del inglés move from low) traslada los 32 bits menos significativos del resultado a un registro destino. Por ejemplo, la instrucción mflo $s0 traslada los 32 bits menos significativos del resultado al registro s0. Cuando se está evaluando una expresión aritmética, interesa que todas las variables tengan el mismo tamaño. Por tanto, después de realizar una multiplicación, interesa almacenar el resultado en 32 bits en lugar de 64 para proseguir operando con el. Si se necesitan más de 32 bits para almacenar el resultado, se habrá producido un desbordamiento de 32 bits. El MIPS no tiene ningún mecanismo hardware para detectarlo, siendo responsabilidad del programador su detección. En el caso de multiplicaciones sin signo basta con comprobar que el registro hi esté a cero. En el caso de números con signo, el registro hi ha de ser todo ceros si lo es positivo o todo unos si lo es negativo. Ejercicio Escriba la secuencia de instrucciones para multiplicar sin signo s0 por s1 y almacenar el resultado en s2. Si se produce un desbordamiento de 32 bits se pondrá t0 a uno y si no se dejará a cero. Repita el ejercicio para números con signo. Aritmética. División El MIPS dispone de dos instrucciones para dividir: div (con signo) o divu (sin signo). El cociente se almacena en lo y el resto en hi. Ej: div $s0, $s1 divide s0 entre s1 Estas instrucciones no detectan división por cero. Estructura de Computadores Capítulo 3b: Programación en ensamblador del MIPS. p. 54

56 Al igual que en la multiplicación, son necesarias dos instrucciones para la división: div para números con signo y divu para números sin signo. En ambos casos el resultado se almacena en el mismo registro de 64 bits utilizado para la multiplicación. En la parte alta (hi) se almacena el resto y en la parte baja (lo) se almacena el cociente. Conviene destacar que el MIPS no detecta la división por cero. Además el resultado obtenido en este caso es inpredecible. Por tanto es tarea del programador el evitar las divisiones por cero para evitar sorpresas desagradables. Ejercicio Escriba una secuencia de instrucciones para dividir s0 entre s1 y almacenar el cociente en el registro s2 y el resto en el registro s3. Si el divisor vale cero no se realizará la división y se pondrá a uno el registro t0. En caso contrario, después de realizar la división se dejará t0 a cero. Los números almacenados en s0 y s1 son números con signo. Aritmética. Ej: (a0+a1)*a2/a3 1 func: beq $a3, $zero, Error 2 add $t0, $a0, $a1 3 mult $t0, $a2 4 mflo $t0 5 mfhi $t1 6 slt $t2, $t0, $zero #res<0? 7 bne $t2, $zero, Nega 8 bne $t1, $zero, Error #res>0 9 j L1 10 Nega: sltiu $t2, $t1, -1 # -1=0xffff 11 bne $t2, $zero, Error 12 L1: div $t0, $a3 13 mflo $v0 14 add $v1, $zero, $zero 15 jr $ra 16 Error: addi $v1, $zero, 1 17 jr $ra Estructura de Computadores Capítulo 3b: Programación en ensamblador del MIPS. p. 55

57 En la transparencia se muestra el código para implementar una función que calcule la expresión (a0+a1)*a2/a3 (variables con signo). El resultado se devolverá en v0 y en v1 se devolverá un 0 si no se ha producido ningún error en el cálculo de la expresión o un 1 si se produce desbordamiento en la multiplicación o una división por cero. En primer lugar se comprueba que a3 no sea cero. Si lo es, se salta al final de la función, desde donde se pone v1 a 1 para indicar el error y se retorna de la función. Si a3 no es cero, se comienza a evaluar la expresión. En primer lugar se realiza la suma. Si ocurriese un desbordamiento se produciría una excepción, desde donde se podría tratar el error. Como aún no se han estudiado las excepciones, se deja la implementación de la rutina de atención a la excepción para más adelante. A continuación se realiza la multiplicación, dejando el resultado en los registros t0 y t1. Como se pretende continuar la evaluación de la expresión usando números de 32 bits, el resultado ha de poderse almacenar en t0, por lo que t1 tendrá que valer 0 si el resultado es positivo o 0xffffffff si el resultado es negativo. Esta comprobación se realiza en las instrucciones 6 a 11. En la instrucción 6 se comprueba el signo del resultado. Si es positivo se ejecutará la instrucción 8 que saltará a la etiqueta Error si t1 no vale cero. Si el resultado es negativo, en la instrucción 10 se comprueba si t1 vale 0xffffffff. Como las instrucciones de comparación extienden el signo de la constante de 16 bits, comparar con -1 es comparar con 0xffffffff. Como la comparación se realiza sin signo, si t1 es distinto de 0xffffffff se producirá el salto en la instrucción 11 para ir a la etiqueta Error. Si no hay desbordamiento en la multiplicación, se procede a realizar la división y a devolver el control a quien ha llamado a la función, aunque previamente se deposita el resultado en v0 y un 0 en v1 para indicar que la evaluación de la expresión se ha realizado con éxito. Ejercicio Modifique la función anterior para comprobar explícitamente el desbordamiento de la suma utilizando el algoritmo mostrado en la página

58 Aritmética y lógica Aparte de la +,-,* y /, el MIPS dispone de una serie de operaciones lógicas y aritméticas adicionales: and dest, orig1, orig2 andi dest, orig1, const or dest, orig1, orig2 ori dest, orig1, const xor dest, orig1, orig2 xori dest, orig1, const nor dest, orig1, orig2 Estructura de Computadores Capítulo 3b: Programación en ensamblador del MIPS. p. 56 Aparte de las operaciones aritméticas estudiadas hasta ahora, en muchos programas es necesario realizar operaciones lógicas a nivel de bit. El MIPS incluye las instrucciones lógicas mostradas en la transparencia. Todas ellas realizan una operación lógica bit a bit entre los dos registros origen y depositan su resultado en el registro destino. Se incluyen las dos operaciones lógicas fundamentales, AND y OR, así como la XOR. Se incluye además la operación NOR, que realiza la misma operación que una OR salvo que se niega el resultado. Esta instrucción permite realizar la operación fundamental NOT. Cómo? Las operaciones AND, OR y XOR disponen de versiones en las cuales el segundo operando es una constante de 16 bits. Como el registro con el que se opera es de 32 bits, los 16 bits superiores de la constante se ponen a 0 antes de realizar la operación lógica. Recuerde que este comportamiento es distinto del ofrecido en las constantes de las operaciones de suma, resta y comparación, en las cuales se extiende el signo.

59 Aritmética y lógica Por último, el MIPS dispone de una serie de instrucciones de desplazamiento de bits. Despl. lógico a izq.: sll rd, ro, desp Despl. lógico a izq. var.: sllv rd, ro, rdes Despl. lógico a der.: srl rd, ro, desp Despl. lógico a der. var.: srlv rd, ro, rdes Despl. aritmético a der.: sra rd, ro, desp Despl. arit. a der. var.: srav rd, ro, rdes Estructura de Computadores Capítulo 3b: Programación en ensamblador del MIPS. p. 57 El MIPS dispone de varias instrucciones de desplazamiento de bits. Estas instrucciones pueden desplazar un registro origen el número de bits especificado en la constante desp o en el registro rdes para los desplazamientos variables. El resultado se almacena en el registro destino. Cuando se desplaza a la izquierda se rellenan los bits vacantes con ceros. Por ejemplo si se desplaza a la izquierda tres posiciones, el resultado será En cambio, cuando se desplaza a la derecha caben dos posibilidades: rellenar con ceros (desplazamiento lógico) o rellenar con el bit de signo (desplazamiento aritmético). Por ejemplo, si se desea desplazar el valor dos bits a la derecha, si se realiza un desplazamiento lógico, el resultado será , pero si se realiza un desplazamiento aritmético, el resultado será Las instrucciones de desplazamiento tienen dos usos fundamentales. Los desplazamientos lógicos se usan para manipular bits. Por ejemplo si se desean extraer los 16 bits más significativos de un registro de 32 bits (s0) y almacenarlos en s1 se puede ejecutar la instrucción srl $s1, $s0, 16. En este tipo de operaciones no es necesario extender el bit de signo, por lo que se usan las instrucciones de desplazamiento lógico. El otro uso de las instrucciones de desplazamiento es para realizar multiplicaciones y divisiones por potencias de dos. Cada bit que se desplaza un número binario a la izquierda es equivalente a multiplicar por 2. De la misma forma, cada bit que se desplaza a la derecha es equivalente a dividir por 2, aunque en este caso si el número es negativo es necesario introducir unos por la izquierda para que se mantenga el signo. Por tanto, cuando se desee desplazar 1 Se han usado en el ejemplo números de 8 bits para simplificar. El MIPS desplaza siempre valores de 32 bits.

60 a la derecha para dividir por potencias de dos, será necesario utilizar desplazamientos aritméticos. Conviene resaltar que en estas operaciones el MIPS no comprueba si se producen desbordamientos Aritmética y lógica. Ejemplo int a, V[100], i, j, k; while(v[i] == k){ i = i + j; } Se traduce en (a-k se asignan a los registros s0-s4): Bucle: sll $t1, $s2, 2 # t1 = 4i add $t1, $t1, $s1 # t1 = dir. de V[i] lw $t0, 0($t1) # t0 = V[i] bne $t0, $s4, Fin # si i!=k salta add $s2, $s2, $s3 # i = i + j j Bucle Fin: Estructura de Computadores Capítulo 3b: Programación en ensamblador del MIPS. p. 58

61 El código C mostrado en la transparencia es el mismo que se utilizó en la página 25. Al igual que antes, es necesario multiplicar por 4 el índice del vector para acceder a cada uno de los elementos. En el programa en ensamblador de la página 25 se utilizaron dos instrucciones de suma para realizar dicha multiplicación. Otra alternativa sería usar una instrucción de multiplicación, aunque en este caso se necesitarían tres instrucciones: addi $t0, $zero, 4 multu $s2, $t0 mflo $t0 Obviamente no es la solución más apropiada. No obstante, si se tiene en cuenta que 4 es una potencia de 2, podemos realizar la multiplicación por 4 mediante desplazamientos. Como 4 = 2 2, para multiplicar por 4 basta con desplazar 2 bits a la izquierda, que es lo que se ha hecho en la primera instrucción del programa en ensamblador. Ejercicio En muchas ocasiones es más eficiente implantar una multiplicación por una constante como una serie de desplazamientos y sumas. Escriba una secuencia de instrucciones en ensamblador que multipliquen el registro s0 por 5 y depositen el resultado en t0. Carga de constantes Hasta ahora se ha visto cómo cargar una constante de 16 bits en un registro. Para cargar un valor de 32 bits (p. ej. 0x ) son necesarias dos instrucciones: lui $s0, 0x1234 ori $s0, $s0, 0x5678 La pseudoinstrucción li hace el mismo trabajo: li $s0, 0x Estructura de Computadores Capítulo 3b: Programación en ensamblador del MIPS. p. 59

62 Aunque la mayoría de las constantes usadas en los programas son menores de 16 bits, en ciertas ocasiones es necesario usar constantes de 32 bits. Para ello, el MIPS dispone de una instrucción de carga especial que toma una constante de 16 bits y la sitúa en los 16 bits más significativos del registro destino, dejando los 16 bits menos significativos a cero. Dicha instrucción se denomina lui (del inglés load upper inmediate). Para cargar los bits menos significativos del registro se usa la instrucción ori, que realiza una OR bit a bit del registro destino con una constante de 16 bits extendida con ceros en su parte superior. Así, en el ejemplo de la transparencia se realizará una OR entre: 0x x Cuyo resultado es 0x Como el lenguaje nativo del MIPS es un poco limitado, dada su naturaleza RISC, los ensambladores del MIPS disponen de una serie de pseudoinstrucciones para facilitarle la vida a los programadores. Dichas pseudoinstrucciones no son más que una especie de abreviaturas de varias instrucciones del MIPS. Una pseudoinstrucción muy útil es la li (de load inmediate), que carga una constante, independientemente de su tamaño, en un registro. Cuando el ensamblador encuentra esta pseudoinstrucción evalúa el tamaño de la constante y si ésta es menor de 16 bits genera la instrucción ori rd, const. Si la constante es mayor de 16 bits, entonces genera la combinación lui+ori vista en la transparencia. Ejercicio Utilizando el simulador SPIM, indique cual es la traducción a instrucciones MIPS de la pseudoinstrucción li para las siguientes constantes: 1, -1 y 0x Se realiza siempre la traducción óptima? Para saber más En este tema sólo se han mostrado algunas de las instrucciones disponibles en el MIPS. Un listado completo se encuentra en el apéndice A de (Patterson y Hennessy, 2000), disponible on-line en la página del SPIM. Los manuales completos de la arquitectura MIPS (MIPS Technologies, 2002) se encuentran también disponibles on-line en la página de MIPS Technologies (accesible desde la página web de la asignatura). Estructura de Computadores Capítulo 3b: Programación en ensamblador del MIPS. p. 60

63 Referencias de Miguel Anasagasti, P. (2000). Fundamentos de los computadores. Paraninfo-Thomson learning. MIPS Technologies (2002). MIPS32 TM Architecture For Programmers. MIPS Technologies, Mountain View, CA, 1 edition. Patterson, D. A. y Hennessy, J. L. (2000). Estructura y diseño de computadores. Interficie circuitería/programación. Reverté.