Prácticas ensamblador MIPS

Vista previa del material en texto

REPÚBLICA BOLIVARIANA DE VENEZUELA
UNIVERSIDAD JOSÉ ANTONIO PAEZ
ESCUELA DE INGENIERÍA EN COMPUTACIÓN
 (
Ejercicios de Prácticas de Ensamblador MIPS
)
Integrantes:
Betancourt, Romina
Centeno, Jorman
jjjjj
Ramirez, Michelle
Cátedra: Arquitectura del Computador
Sección: 308C1
Prof. Raniere Alezones
San Diego, Junio, 2016
Ejercicio 4: (Aplicación 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 continuación el programa debe cargar en el registro t0 el dato array[2] y en el registro t1 el dato array[4].
NOTA DE ROMINA (LE YO) Favor chicos revisar y completar éste código, algunas veces me dá bien y otras no (no sé por qué? please)
#Problema 1: Cargar en los registros s0, s1, s2 , s3 y s4 el vector denominado array_media.
.data
array_media: .half 2, 4, 6, 8, 10
	.text
	.globl main
main:
	la $t1,array_media 	#Apunta a la dirección del 1º elemento de array_media 
	lh $s0,0($t1) 		#Carga el 1º elemento del vector en s0
	lh $s1,2($t1) 		#Carga el 2º elemento del vector en s1
	lh $s2,4($t1) 		#Carga el 3º elemento del vector en s2
	lh $s3,6($t1) 		#Carga el 4º elemento del vector en s3
	lh $s4,8($t1) 		#Carga el 4º elemento del vector en s3
#ahora se carga en el registro t0 el dato array[2] y en el registro t1 el dato array[4]
	lh $s0,2($t1) 		#Carga el 1º elemento del vector en s0
	lh $s1,4($t1) 		#Carga el 2º elemento del vector en s1
#salida del sistema
	lh $t1,10
	syscall
Ejercicio 5: (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 
# Estructura de Computadores. 2º ITIS CUM-UEX 2004/2005 
# Ejercicio 5 
.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 : función de syscall: print_string 
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)? 
· Con “la $a0, string” seleccionamos la dirección base del buffer donde se va a escribir la cadena que introduciremos por consola (teclado) y se “reescribirá” cualquier cadena escrita en esa posición anteriormente.
· Por tanto, vamos a “reescribir” lo que haya a partir de esa dirección (lo que había antes era “Hola Mundo \n”). 
· Igualmente, al terminar de escribir la cadena (así pretenda pasarse de los 9 caracteres), a accionar la tecla “Enter” estamos poniendo el carácter nulo, indicando el final de la cadena. 
2. ¿Qué ocurre si nos pasamos de caracteres al introducir la cadena por teclado en (4)? 
Sólo muestra 9 caracteres programado en la línea de código especificada en “li $a1,9” en donde se limita a 9 caracteres el tamaño del buffer (porción de memoria) donde irá la cadena. 
3. ¿Qué hace el fragmento de código (5)? 
Imprime un elemento desde un array de enteros que está en el segmento de datos.
4. ¿Qué hace el fragmento de código (6)? 
Muestra en la consola la cadena introducida, usando “li $v0,4” y “syscall” hace la llamada al sistema.
Ejercicio 6: (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 
# Estructura de Computadores. 2º ITIS CUM-UEX 2004/2005 
# Ejercicio 6 
.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 		# (1)i=2 : Índice del elemento del array "a" 
la $s1,a 		# (2)p=&a[0]=a, dirección base del array "a" 
mul $t0,$s0,4 	# (3)$t0 tiene el desplazamiento (en bytes) 
# del elemento a[i] del array 
add $t1,$s1,$t0 	# (4)$t1=p+4*i $t1 tiene la dirección del 
# elemento a[i] del array 
lw $t2,0($t1) 	# (5)$t2 tiene el elemento a[i] 
lw $s0,X 		# (6)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 (7)
syscall (8)
El código sirve para acceder a datos (palabras y byte) que pertenecen a arrays de datos en memoria cuando no están alineados.
(1) Carga el 2do elemento del vector en $s0
(2) Prepara una variable “a” para interpretarla como un elemento cualquiera del mismo “array a”.
(3) La instrucción "mul” multipla los valores en la posición 0 como desplazamiento de $t0 en elemento a[i] del array .
(4) add $t1,$s1,$t0 significa que se sumaran los valores enteros ubicados en $t1 quien tiene la dirección del elemento a[i] del array.
(5) copia los valores del “array a” de t1 en t2.
(6) Cuando las posiciones x,y,z no se encuentran alineados se utilizan las instrucciones lw para cargar una palabra y lb para carghar un byte
(7) Muestra en la consola la cadena introducida, usando “li $v0,19” 
(8) “syscall” hace la llamada al sistema.
Ejercicios de Prácticas de Ensamblador MIPS	Página 4