EJERCICIOS DE PRACTICAS DE ENSAMBLADOR MIPS

ESTRUCTURA / ORGANIZACIN DE COMPUTADORES

BOLETN N 1

Ejercicio 1: (Operaciones bsicas con la memoria)
Estudiar el siguiente programa en ensamblador del MIPS, que carga en la memoria los
datos siguientes: los bytes correspondientes a la cadena !Hola Mundo! y a continuacin los
datos en forma de bytes: 5,10,15,20,25,30,35,40. Consultar las transparencias 8 y 16 del
tutorial del lenguaje ensamblador del MIPS.
# Pr ct i cas ensambl ador MI PS
# Est r uct ur a de Comput ador es. 2 I TI S CUM- UEX 2004/ 2005
# Ej er ci ci o 1
. dat a
. asci i z " Hol a Mundo! \ n"
. byt e 5, 10, 15, 20, 25, 30, 35, 40
. t ext
Cargar el programa en el simulador.
Interpretar el contenido de las direcciones de memoria (consultar las transparencias
14, 15 y 26 del tutorial y tambin la tabla de cdigo ASCII).
La siguiente tabla puede servir de ayuda:

ASCI I ! H o l a M u n d o ! \ n NULL
Deci mal 33 72 111 108 97 32 77 117 110 100 111 33 10 0
Hexa-
deci mal
21 48 6f 6c 61 20 4d 75 6e 64 6f 21 0a 00

Ejercicio 2: (Operaciones bsicas con la memoria)
Realizar un programa en ensamblador del MIPS que cargue en la memoria,
consecutivamente, los siguientes datos:
Los siguientes bytes: 16, 32, 48.
Las siguientes medias palabras: 16, 32, 48.
Las siguientes palabras:16, 32, 48.
Cargar el programa en el simulador e interpretar el contenido de las direcciones de memoria.

1
Ejercicio 3: (Arrays y constantes en memoria. Carga de memoria a registros)
Cargar en el simulador SPIM el siguiente programa:
# Pr ct i cas ensambl ador MI PS
# Est r uct ur a de Comput ador es. 2 I TI S CUM- UEX 2004/ 2005
# Ej er ci ci o 3

.data # *** SEGMENTO DE DATOS ***
valor: .word 5,10,15,20 # Defino array 4 palabras (decimal).
# valor[2] es 15 = 0xf
ind: .word 1 # Usado como ndice del array "valor"
.byte 0x1a,0x0b,10 # Defino los 3 primeros bytes de la
# siguiente palabra (hex. y dec.).
.align 2 # Alineo el siguiente dato en memoria
# para que est alineado en palabra
# (empiece en una palabra)
.ascii "Hola" # Cadena de caracteres
.asciiz",MIPS" # Cadena de caracteres terminada
# con el caracter nulo.

#---------------------------------------------------------------------------
.text # *** SEGMENTO DE TEXTO ***
.globl main # Etiqueta main visible a otros ficheros
main: # Rutina principal
lw $s0,valor($zero) # Carga en $s0 valor[0]. ($s0 <-- valor[0])
# Tambin vale: lw $s0,valor

lw $s4,ind # $s4 <-- ndice del array
mul $s5,$s4,4 # $s5 <-- ind*4
lw $s1,valor($s5) # $s1 <-- valor[1]

add $s4,$s4,1 # Incrementamos el ndice del array
mul $s5,$s4,4
lw $s2,valor($s5) # $s2 <-- valor[2]

add $s4,$s4,1 # Incrementamos el ndice del array
mul $s5,$s4,4
lw $s3,valor($s5) # $s3 <-- valor[3]

Comprobar en la ventana de mensajes que la carga ha sido correcta.
Comprobar en la ventana del segmento de datos que todos los bytes que aparecen
en las palabras de memoria corresponden con las definiciones de datos que
aparecen en las directivas del cdigo ensamblador.
Estudiar el contenido de la ventana de registros. Observar los registros que aparecen
y sus valores (ver el listado de los registros del MIPS y sus distintos valores en la
transparencia n 9 del tutorial).
Estudiar el contenido de la ventana del segmento de texto.
Escribir el valor que deber tomar cada registro tras ejecutarse cada lnea de
cdigo.
Ejecutar el programa cargado en SPIM.
Comprobar que los valores que van tomando los registros al ejecutarse las
operaciones descritas en las lneas de cdigo son los esperados.
Estudiar cmo se cargan en registros las distintas posiciones de un array de datos en
memoria y qu operaciones aritmticas es necesario realizar (y por qu).
Estudiar las directivas e instrucciones que aparecen en el cdigo (ver transparencia
n 8 del tutorial).

2
Ejercicio 4: (Aplicacin de arrays y ctes. en memoria. Carga de memoria a registros)
Realizar un programa en ensamblador del MIPS que cargue en un array de datos en
memoria (etiquetado como array) los siguientes enteros: 2, 4, 6, 8, 10. A continuacin el
programa debe cargar en el registro t0 el dato array[2] y en el registro t1 el dato array[4].

Ejercicio 5: (Llamadas al sistema, entrada/salida en consola, fin ejecucin de un progr.)
Cargar en el simulador SPIM el siguiente programa:
# Pr ct i cas ensambl ador MI PS
# Est r uct ur a de Comput ador es. 2 I TI S CUM- UEX 2004/ 2005
# Ej er ci ci o 5
. dat a
st r i ng: . asci i z " Hol a Mundo! \ n"
i t em: . wor d 99
ar r ay: . wor d 11, 22, 33, 44, 55, 66, 77, 88, 99
#- - - - - - - - - - - - - - - - - - - - - - - #
. t ext
. gl obl mai n
mai n:
#- - - - - - - - - - - - - - - - - - - #( 1) Escr i be una cadena en consol a
l a $a0, st r i ng # car ga di r ecc. base de l a cadena en $a0
l i $v0, 4 # $v0 <- - 4 : f unci n de syscal l : pr i nt _st r i ng
syscal l # Ll amada al si st ema. I mpr i me t odos l os
# car act er es desde di r ecc. " st r i ng"
# hast a car act er f i n de cadena ( NULL)
# ( byt e " 00" )
#- - - - - - - - - - - - - - - - - - - #( 2) Escr i be un ent er o en consol a
l w $a0, i t em
l i $v0, 1
syscal l
#- - - - - - - - - - - - - - - - - - - #( 3) Lee un ent er o desde consol a
# ( esper a a que l o i nt r oduzca por t ecl ado)
# y l o escr i be en consol a
l i $v0, 5
syscal l
#- - - - - - - - - - - - - - - - - - - #( 4) Lee una cadena de consol a
l i $v0, 8 # f unci n de syscal l : r ead_st r i ng
l a $a0, st r i ng # di r ec. base del buf f er donde se escr i be
# l a cadena i nt r oduci da por consol a ( t ecl ado)
l i $a1, 9 # t amao del buf f er : 9 car act er es
syscal l # Lect ur a de cadena
l i $v0, 4
syscal l # Escr i t ur a de l a cadena en consol a
#- - - - - - - - - - - - - - - - - - - #( 5)
l i $t 0, 3
l i $t 1, 4
mul $t 2, $t 1, $t 0
l w $a0, ar r ay( $t 2)
l i $v0, 1
syscal l
#- - - - - - - - - - - - - - - - - - - #( 6)
l i $v0, 10
syscal l
Estudiar las funciones que realiza el cdigo, fijndose en particular en la funcionalidad de
cada seccin de cdigo. Responder las preguntas:
1. Qu ocurre con el contenido que hubiera previamente en las direcciones de memoria
donde se almacena la cadena introducida en (4)?
2. Qu ocurre si nos pasamos de caracteres al introducir la cadena por teclado en (4)?
3. Qu hace el fragmento de cdigo (5)?
4. Qu hace el fragmento de cdigo (6)?
3
Ejercicio 6: (Manipulacin array de datos en memoria, carga datos no alineados en mem.)
Cargar y ejecutar en el simulador SPIM el siguiente programa.
Estudiar las funciones que realiza el cdigo, fijndose en particular en la funcionalidad de
cada seccin de cdigo.
# Pr ct i cas ensambl ador MI PS
# Est r uct ur a de Comput ador es. 2 I TI S CUM- UEX 2004/ 2005
# Ej er ci ci o 6
. dat a
X: . wor d 5
Y: . byt e 3
Z: . wor d 6
s: . asci i z " Hol a\ n"
a: . wor d 10, 3, 5, 2, 6
#- - - - - - - - - - - - - - - - - - - - - - - - - #
. t ext
. gl obl mai n
mai n:
#- - - - - - - - - - - - - - - - - - - - - - - - - # Voy a l eer en un r egi st r o un el ement o
# del ar r ay " a" , el el ement o a[ 2]

l i $s0, 2 # i =2 : ndi ce del el ement o del ar r ay " a"
l a $s1, a # p=&a[ 0] =a, di r ecci n base del ar r ay " a"
mul $t 0, $s0, 4 # $t 0 t i ene el despl azami ent o ( en byt es)
# del el ement o a[ i ] del ar r ay
add $t 1, $s1, $t 0 # $t 1=p+4*i $t 1 t i ene l a di r ecci n del
# el ement o a[ i ] del ar r ay
l w $t 2, 0( $t 1) # $t 2 t i ene el el ement o a[ i ]

l w $s0, X # Los dat os et i quet ados con X, Y, Z no est n
l b $s1, Y # al i neados. Par a poder car gar l os en l os
l w $s2, Z # r egi st r os, usamos l a i nst r ucci n " l w"
# cuando es una pal abr a y " l b" si es un byt e

#- - - - - - - - - - - - - - - - - - - - - - - - - # Fi n del pr ogr ama
l i $v0, 10
syscal l

Ejercicio 7: (Aplicacin entrada/salida y manipulacin array de datos)
a) Realizar un programa en ensamblador del MIPS que cargue en un array de datos en
memoria los siguientes enteros: 6, 8, 10, 12. A continuacin el programa debe leer un entero
de consola, guardarlo en la posicin 1 del array machacando el dato existente (8) y escribir
en consola todos los elementos del array.
b) Modificar el programa para que escriba en consola los elementos del array cada uno en
una lnea diferente.
4