Parte 1
(Arrays y constantes en memoria. Carga de memoria a registros)
Cargar en el simulador SPIM el siguiente programa:
# Prácticas ensamblador MIPS
.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 <-- p="" valor=""># También vale: lw $s0,valor
lw $s4,ind # $s4 <-- array="" del="" ndice="" p="">mul $s5,$s4,4 # $s5 <-- ind="" p="">lw $s1,valor($s5) # $s1 <-- p="" valor="">add $s4,$s4,1 # Incrementamos el índice del array
mul $s5,$s4,4
lw $s2,valor($s5) # $s2 <-- p="" valor="">add $s4,$s4,1 # Incrementamos el índice del array
mul $s5,$s4,4
lw $s3,valor($s5) # $s3 <-- p="" valor="">
• 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 código 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 línea de código.
• Ejecutar el programa cargado en SPIM.
• Comprobar que los valores que van tomando los registros al ejecutarse las operaciones descritas en las líneas de código son los esperados.
• Estudiar cómo se cargan en registros las distintas posiciones de un array de datos en memoria y qué operaciones aritméticas es necesario realizar (y por qué).
• Estudiar las directivas e instrucciones que aparecen en el código (ver transparencia nº 8 del tutorial).
Parte 2
(Llamadas al sistema, entrada/salida en consola, fin ejecución de un progr.)
Cargar en el simulador SPIM el siguiente programa:
# Prácticas ensamblador MIPS
.data
string: .asciiz "¡Hola Mundo!\n"
item: .word 99
array: .word 11,22,33,44,55,66,77,88,99
#-----------------------#
.text
.globl main
main:
#-------------------#(1) Escribe una cadena en consola
la $a0,string # carga direcc. base de la cadena en $a0
li $v0,4 # $v0 <-- 4="" :="" de="" funci="" n="" p="" print_string="" syscall:="">syscall # Llamada al sistema. Imprime todos los
# caracteres desde direcc. "string"
# hasta caracter fin de cadena (NULL)
# (byte "00")
#-------------------#(2) Escribe un entero en consola
lw $a0,item
li $v0,1
syscall
#-------------------#(3) Lee un entero desde consola
# (espera a que lo introduzca por teclado)
# y lo escribe en consola
li $v0,5
syscall
#-------------------#(4) Lee una cadena de consola
li $v0,8 # función de syscall: read_string
la $a0,string # direc. base del buffer donde se escribe
# la cadena introducida por consola (teclado)
li $a1,9 # tamaño del buffer: 9 caracteres
syscall # Lectura de cadena
li $v0,4
syscall # Escritura de la cadena en consola
#-------------------#(5)
li $t0,3
li $t1,4
mul $t2,$t1,$t0
lw $a0,array($t2)
li $v0,1
syscall
#-------------------#(6)
li $v0,10
syscall
Estudiar las funciones que realiza el código, fijándose en particular en la funcionalidad de cada sección de código. 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 código (5)?
4. ¿Qué hace el fragmento de código (6)?
Parte 3
(Manipulación 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 código, fijándose en particular en la funcionalidad de cada sección de código.
# Prácticas ensamblador MIPS
.data
X: .word 5
Y: .byte 3
Z: .word 6
s: .asciiz "Hola\n"
a: .word 10,3,5,2,6
#-------------------------#
.text
.globl main
main:
#-------------------------# Voy a leer en un registro un elemento
# del array "a", el elemento a[2]
li $s0,2 # i=2 : Índice del elemento del array "a"
la $s1,a # p=&a[0]=a, dirección base del array "a"
mul $t0,$s0,4 # $t0 tiene el desplazamiento (en bytes)
# del elemento a[i] del array
add $t1,$s1,$t0 # $t1=p+4*i $t1 tiene la dirección del
# elemento a[i] del array
lw $t2,0($t1) # $t2 tiene el elemento a[i]
lw $s0,X # Los datos etiquetados con X,Y,Z no están
lb $s1,Y # alineados. Para poder cargarlos en los
lw $s2,Z # registros, usamos la instrucción "lw"
# cuando es una palabra y "lb" si es un byte
#-------------------------# Fin del programa
li $v0,10
syscall
Parte4
(Aplicación entrada/salida y manipulación 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 continuación el programa debe leer un entero de consola, guardarlo en la posición 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 línea diferente.
