El lenguaje ensamblador es un lenguaje de programación de bajo nivel para los computadores, microprocesadores, microcontroladores y otros circuitos integrados programables. Implementa una representación simbólica de los códigos de máquina binarios y otras constantes necesarias para programar una arquitectura dada de CPU y constituye la representación más directa del código máquina específico para cada arquitectura legible por un programador. Está basada en procesos nemónicos que simbolizan los pasos de procesamiento (las instrucciones), los registros del procesador, las posiciones de memoria y otras características del lenguaje.
Con el nombre de MIPS se conoce a toda una familia de microprocesadores de arquitectura RISC desarrollados por MIPS Technologies. Nosotros trabajaremos con uno de 32 bits, el cual utiliza un banco de 32 registros de 32 bits.
Los temas 1 y 2 de las unidades teóricas nos hacen una gran introducción a dicho ensamblador y nos familiariza con sus registros, servicios del sistema, directivas, instrucciones y estructuras más utilizadas a la hora de hacer programas sencillos.
Para que sea más claro empezamos con una introducción a Mars mediante un ejercicio ya resuelto de Fibonacci, el cual debemos modificarlo.
En esta práctica nos muestran modos de direccionamientos y como especificarlos. La mayoría de instrucciones de Mips utilizan como operandos los registros, pero existen algunas capaces de acceder a memoria. Con los vectores ocurre esto, solo pueden guardarse en memoria; lo que si puede almacenarse en los registros, es la dirección del primer elemento del vector y a continuación será posible acceder al resto de elementos usando el modo de direccionamiento relativo a registro base y así comenzamos a realizar ejercicios:
EJEMPLO:
.data
array_byte: .byte 60,61,62,63
array_media: .half 10,20,30,40
array_palabra: .word -1,-2,-3,-4
.text
.globl main:
main:
la $t1,array_byte #Apunta a la dirección del 1º elemento de array_byte
lb $s0,0($t1) # Carga el 1º elemento del vector en s0
lb $s1,1($t1) # Carga el 2º elemento del vector en s1
lb $s2,2($t1) # Carga el 3º elemento del vector en s2
lb $s3,3($t1) # Carga el 4º elemento del vector en s3
De este ejemplo de programa debemos realizar los primeros dos ejercicios:
Ejercicio 1: Ejercicio 2:
main: main:
la $t2,array_media la $t3,array_palabra
lb $s0,0($t2) lb $s0,0($t3)
lb $s1,2($t2) lb $s1,4($t3)
lb $s2,4($t2) lb $s2,8($t3)
lb $s3,6($t2) lb $s3,12($t3)
En estos dos ejercicios lo único que debemos hacer es modificar el código para que se cargue en los registros s0,s1,s2,s3 los array_media y palabra respectivamente. También nos sirve para aprender la instrucción “lb” que nos permite acceder a cada byte de una palabra de memoria.
LLAMADAS AL SISTEMA
A continuación nos introducimos en comandos para mostrar por pantalla algunos elementos pertenecientes al array.
Ejercicio 3:
En este ejercicio debemos mostrar por pantalla sólo los elementos impares del array del código anterior.
“move”à#Mueve el contenido del registro $s0 al registro $a0
“li”à# Cargar valor inmediato en $v0
“Syscall”à# Llamada al sistema, el registro v0 contiene el número de la llamada al sistema.
Ejercicio 4:
El problema 4, es muy parecido al anterior, pero en lugar de mostrar los elementos impares, mostramos los elementos pares del array tratado (array_palabra), separados por una coma.
“la”à #Carga dirección ”coma” en $a0 (el valor de dirección, no el contenido)
Ejercicio 5:
En el problema 5, ya no teníamos que modificar código, por primera vez, escribíamos un programa por nosotros mismos, sin un guión ya establecido en cuanto a código se refiere.
Este programa, realiza la suma de dos valores almacenados en memoria, y el resultado lo guardamos en un espacio de memoria reservado anteriormente.
“lw”à carga una palabra de la dirección numero1 en $t0
“add”à Suma con desbordamiento.
ACCESO A VECTORES MEDIANTE INDICES
1-Mediante suma: suma todos los elementos de un array.
.data
valor: .word 0xa,0xb,0x01,0x02
.text
.globl main
main:
move $t0,$zero # $t0<-- "índice" con valor inicial 0
move $t1,$zero # $t1<-- "suma" con valor inicial 0
li $t2,4 # $t2<-- constante
la $s0, valor
bucle:
add $t3,$t0,$t0 # t3 = indice +indice = 2 * indice
add $t3,$t3,$t3 # t3 = 2*indice + 2*indice = 4 * indice
add $t4,$s0,$t3 # Suma del desplazamiento a la dirección base, t1= base + 4*i
lw $s1,0($t4) # Carga del elemento referenciado por la dirección guardada en t1, se carga en s1
add $t1,$t1,$s1 # Suma el elemento a la suma anterior
add $t0,$t0,1 # Incremento del índice
blt $t0,$t2,bucle # Repite el bucle si no se ha llegado al último elemento
2-Mediante multiplicación: suma de todos los elementos de un array
.data
valor: .word 0xa,0xb,0x01,0x02 # Defino array 4 palabras (decimal).
.text
.globl main
main:
move $t0,$zero # $t0<-- "indice" con valor incial 0
move $t1,$zero # $t1<-- "suma" con valor incial 0
li $t2,4 # $t2<-- constante
li $t7,4 # $t7 <-- factor
bucle:
mul $t4,$t0,$t7 # $t4 <-- indice*4
lw $s1,valor($t4) # $s1 <-- valor[indice]
add $t1,$t1,$s1 # suma = suma + valor[indice]
add $t0,$t0,1 # Incrementamos el índice del array
blt $t0,$t2,bucle # Repite el bucle si no se ha llegado al utlimo elemento (indice<4)
3-Mediante desplazamiento aritmético a la izquierda:
.data
valor: .word 0xa,0xb,0x01,0x02 #Defino array 4 palabras
.text
.globl main
main:
move $t0,$zero # $t0<-- "indice" con valor incial 0
move $t1,$zero # $t1<-- "suma" con valor incial 0
li $t2,4 # $t2<-- constante
bucle:
sll $t3,$t0,2 # Desplazamiento de dos bits a la izquierda de "indice"
lw $t4,valor($t3) # $t4 <-- valor[indice]
add $t1,$t1,$t4 # suma=suma+valor [indice]
add $t0,$t0,1 # índice=índice+1
ble $t0,$t2,bucle # Repite BUCLE si índice<4
Una vez analizados los ejemplos de códigos anteriores y entendido su contenido, estamos listos para realizar el restos de ejercicios de la practica:
En este ejercicio lo que hacemos es modificar el código anterior, reservamos una palabra con la etiqueta “Suma” donde guardaremos posteriormente el resultado de la suma de los elementos del array.
Diseñe un código para almacenar en un array en memoria, denominado array1, los siguientes valores enteros de 32 bits: 5, 13,-7,-5, 17.
Ejercicio 6:
En este ejercicio lo que hacemos es modificar el código anterior, reservamos una palabra con la etiqueta “Suma” donde guardaremos posteriormente el resultado de la suma de los elementos del array.
Además la instrucción “ble” (Bif. Condicional si Rsrc1 es menor o igual a Src2 (con signo)), lo sustituimos por “blt” (Bif. Condicional si Rsrc1 es menor que Src2 (con signo)).
Ejercicio 7:
Ejercicio 8:
Copie el contenido de array1, de 5 elementos enteros y ubicado al principio de la memoria de datos, en array 2, situado dos posiciones más delante de array1.
Array1={2,34,12,-4,6}
Ejercicio 9:
Diseñe el código de un programa que determine el elemento de mayor valor dentro de un array de cuatro elementos. Debe mostrar por pantalla tanto el índice del elemento como el valor, precedidos ambos por los textos: “Indice” y “Valor”.
Ejercicio 10:
Diseñe un código que pida por teclado dos valores enteros, que los sume y muestre el resultado por pantalla.
Ejercicio 11:
Mediante índices y bucles desarrolle un código que muestre por pantalla un array de bytes almacenado en memoria. La presentación por pantalla atenderá al siguiente formato: “<Nombre del ARRAY>”={VALOR 1, VALOR 2,…}.
Realizado por: Daniel Cabrera López.
FAQ´s
Este icono ejecuta el programa
hasta su finalización.
Este icono reinicia el programa
y el simulador a los valores iniciales.
Este icono indica modo “paso a
paso”.
Su contrario es, “Un solo paso
atrás” (deshace casa operación).
1. ¿Qué
es un lenguaje ensamblador?
El lenguaje ensamblador es un tipo de lenguaje de bajo nivel utilizado para escribir programas informáticos, y constituye la representación más directa del código máquina específico para cada arquitectura de computadoras legible por un programador.
Es un lenguaje creado a base de instrucciones representadas por mnemónicos para intentar sustituir el lenguaje máquina por uno más similar al utilizado por el hombre.
2. ¿Qué software necesito para empezar
a programar en ensamblador?
El
software a descargar será el MARS, que es libre y gratuito, con una interfaz
fácil de usar para editar y desarrollar nuestro programa.
Se puede
conseguir en la página de la UCA.
3. ¿Cómo
guardo mi programa?¿Puedo editarlo más tarde?
Puedes guardar tu programa haciendo click en la
pestaña “FILE”, en donde aparecerán varias opciones, entre ellas la de guardar.
Otra forma de guardar es pulsando Ctrl+s.
Si puedes editarlo, tan solo tienes que abrir el
MARS y hacer Click en la pestaña “FILE” y veras la opción “Open”, ahí puedes
seleccionar el archivo de tu programa.
4. He
realizado cambios y el programa no me ensambla ¿A qué se puede deber?
Puede deberse a que no hallas guardado las
modificaciones realizadas antes de ensamblarlo.
5. ¿Cómo
pongo comentarios en mi código?
Debemos de colocar # antes del comentario que
queramos poner.
6. ¿Cómo
puedo seguir la ejecución de mi programa en MARS?
En la parte superior derecha de la pantalla.
Este icono ejecuta el programa
hasta su finalización.Este icono reinicia el programa
y el simulador a los valores iniciales.Este icono indica modo “paso a
paso”.Su contrario es, “Un solo paso
atrás” (deshace casa operación).
7. ¿Cómo
funcionan los bucles MIPS?
En MIPS,
los bucles funcionan de diferente manera que los lenguajes de alto nivel. Para
realizar un bucle en nuestro programa, necesitamos incluir instrucciones de
salto. Para poder realizar correctamente un salto, es necesario incluir
etiquetas, las cuales se añaden escribiéndolas al principio de la línea en
cuestión, seguidas de dos puntos “:”. En función de lo que queramos hacer con
el programa, se necesitará realizar un salto a una etiqueta u otra según lo que se desee hacer.
Realizado por: Manuel Ponce Torti.
No hay comentarios:
Publicar un comentario