Programación en ensamblador del MIPS. - Departamento de ...

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
ICAIdea
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.
ICAIdea
Estructura de Computadores Capítulo 3b: Programación en ensamblador del MIPS.– p. 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.
ICAIdea
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:
http://www.cs.wisc.edu/˜larus/spim.html
1 El nombre SPIM es simplemente MIPS escrito al revés.

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.
ICAIdea
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.

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
ICAIdea
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).

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)
ICAIdea
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.

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.
ICAIdea
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.

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
ICAIdea
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.

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
ICAIdea
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.

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
ICAIdea
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.

Acceso a memoria
Es necesario acceder a memoria para usar:
• Vectores y matrices.
• Estructuras de datos.
• Variables que no están en registros.
ICAIdea
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.

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
8
4
0
msB lsB
8 9 A B
4 5 6 7
0 1 2 3
Dir. Byte
ICAIdea
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.

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
ICAIdea
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.

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]
ICAIdea
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.

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
ICAIdea
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];

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:
000000 10001 10010 01000 00000 100000
La representación binaria está dividida en campos
para simplificar su decodificación en el hardware.
ICAIdea
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.

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
0 17 18 8 0 32
000000 10001 10010 01000 00000 100000
Tipo R
ICAIdea
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.

Codificación en lenguaje máquina
lw $t0, 32($s2)
Operación
Destino
Despl.
R. Base
Operación Destino
Fuente 1
35 18 8
32
100011 10010 01000 0000000000010000
Tipo I
ICAIdea
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

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.
18-2
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) 35 17 8 1200
add $t0, $t0, $s0 0 8 16 8 0 32
sw $t0, 1200($s1) 43 17 8 1200
ICAIdea
Estructura de Computadores Capítulo 3b: Programación en ensamblador del MIPS.– p. 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 · 4Byte/pal = 1200Bytes).
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
100011 10001 01000 0000 0100 1011 0000
000000 01000 10000 01000 00000 100000
101011 10001 01000 0000 0100 1011 0000
La única diferencia entre la 1 a y la 3 a instrucción es el
tercer bit.
ICAIdea
Estructura de Computadores Capítulo 3b: Programación en ensamblador del MIPS.– p. 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:
240386168
17842208
2921858224
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
ICAIdea
Estructura de Computadores Capítulo 3b: Programación en ensamblador del MIPS.– p. 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
ICAIdea
Estructura de Computadores Capítulo 3b: Programación en ensamblador del MIPS.– p. 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

Toma de decisiones. Ejemplo
ICAIdea
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

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;
}

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
ICAIdea
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

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:
ICAIdea
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.

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.
ICAIdea
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 (==, !=, , =). 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

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, 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

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.
ICAIdea
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.

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.
ICAIdea
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.

En la siguiente transparencia se discute la solución adoptada por los arquitectos del MIPS.
29-2
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.
ICAIdea
Estructura de Computadores Capítulo 3b: Programación en ensamblador del MIPS.– p. 30

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
ICAIdea
Estructura de Computadores Capítulo 3b: Programación en ensamblador del MIPS.– p. 31

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
ICAIdea
Estructura de Computadores Capítulo 3b: Programación en ensamblador del MIPS.– p. 32

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
ICAIdea
Estructura de Computadores Capítulo 3b: Programación en ensamblador del MIPS.– p. 33

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.
ICAIdea
Estructura de Computadores Capítulo 3b: Programación en ensamblador del MIPS.– p. 34

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):
ICAIdea
Estructura de Computadores Capítulo 3b: Programación en ensamblador del MIPS.– p. 35

Llamadas a funciones. Ejemplo
fact: slti $t0, $a0, 1 # 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)
ICAIdea
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

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

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.
ICAIdea
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.

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
ICAIdea
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.

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.
ICAIdea
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.

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
ICAIdea
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.

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
ICAIdea
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.

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.
ICAIdea
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.

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 11111111
• -1 en 16 bits es 11111111 11111111
• -1 en 32 bits es 11111111 11111111 11111111
11111111
Esta extensión es necesaria porque los circuitos
aritméticos operan sólo con números de 32 bits.
ICAIdea
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 11111111
• 255 en 32 bits es 00000000 00000000 00000000
11111111
ICAIdea
Estructura de Computadores Capítulo 3b: Programación en ensamblador del MIPS.– p. 44

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.
ICAIdea
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 11111110 (-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 11111110 (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.

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.
ICAIdea
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.

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
ICAIdea
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).

Aritmética. Números con y sin signo
Ejemplo:
• s0 = 11111111 11111111 11111111 11111111
• s1 = 00000000 00000000 00000000 00000001
¿Cuanto valen t0 y t1 después de ejecutar las
instrucciones
slt $t0, $s0, $s1 # Con signo
sltu $t1, $s0, $s1 # Sin signo
ICAIdea
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 ó 4.294.967.295 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.

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.
ICAIdea
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.

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.
ICAIdea
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

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 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
ICAIdea
Estructura de Computadores Capítulo 3b: Programación en ensamblador del MIPS.– p. 51

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
ICAIdea
Estructura de Computadores Capítulo 3b: Programación en ensamblador del MIPS.– p. 52

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 2 32 -t1, el resultado de la operación anterior será 2 32 -t1-1. Si se
compara este resultado con t2, tenemos que:
(1)
2 32 − t1 − 1 < t2 ⇔ 2 32 − 1 < t1 + t2
Por tanto, si el resultado de la comparación es cierto, el resultado de t1+t2 será mayor de
2 32 − 1 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.
ICAIdea
Estructura de Computadores Capítulo 3b: Programación en ensamblador del MIPS.– p. 53

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.
ICAIdea
Estructura de Computadores Capítulo 3b: Programación en ensamblador del MIPS.– p. 54

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 #res0
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
ICAIdea
Estructura de Computadores Capítulo 3b: Programación en ensamblador del MIPS.– p. 55

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 51
55-2

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
ICAIdea
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.

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
ICAIdea
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 01000111 a la izquierda tres posiciones, el resultado será 00111000.
1 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 10010011 dos bits a la derecha, si se realiza un desplazamiento lógico, el
resultado será 00100100, pero si se realiza un desplazamiento aritmético, el resultado será
11100100.
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.

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.
57-2
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:
ICAIdea
Estructura de Computadores Capítulo 3b: Programación en ensamblador del MIPS.– p. 58

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. 0x12345678)
son necesarias dos instrucciones:
lui $s0, 0x1234
ori $s0, $s0, 0x5678
La pseudoinstrucción li hace el mismo trabajo:
li
$s0, 0x12345678
ICAIdea
Estructura de Computadores Capítulo 3b: Programación en ensamblador del MIPS.– p. 59

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:
0x12340000
0x00005678
Cuyo resultado es 0x12345678.
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 0x10007. ¿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).
ICAIdea
Estructura de Computadores Capítulo 3b: Programación en ensamblador del MIPS.– p. 60

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é.