Introducción al ASM I
*Nota: *1 quiere decir que dicha línea es solo parte de este tutorial, no se usa a la hora de programar.
“Pe.:” se refiere a un ejemplo explicativo. Pe.: ~ Por ejemplo
~: Se refiere al significado o a una equivalencia.
Prologo
“Vistos a muy bajo nivel, los microprocesadores procesan exclusivamente señales electrónicas binarias. Dar una instrucción a un microprocesador supone en realidad enviar series de unos y ceros espaciadas en el tiempo de una forma determinada. Esta secuencia de señales se denomina código máquina. El código representa normalmente datos y números e instrucciones para manipularlos. Un modo más fácil de comprender el código máquina es dando a cada instrucción un mnemónico, como por ejemplo CMP, ADD o JMP. Esta abstracción da como resultado el ensamblador, un lenguaje de muy bajo nivel que es específico de cada microprocesador.
Los lenguajes de bajo nivel permiten crear programas muy rápidos, pero que son a menudo difíciles de aprender. Más importante es el hecho de que los programas escritos en un bajo nivel son prácticamente específicos para cada procesador. Si se quiere ejecutar el programa en otra máquina con otra tecnología, será necesario reescribir el programa desde el principio.”
Ensamblador, en si, es el programa que se encarga, básicamente, de convertir el código de fuente que escribimos, en números, con el objeto de que la maquina lo entienda. Aunque en realidad, lo convierte en un código objeto, que es una herramienta que se creo para poder unir varias rutinas hechas en diferentes lenguajes. Lo que crea el ejecutable se llama “Linker”.
*Algunos de los ensambladores mas usados son el TASM y el MASM.
Breve introducción al Microprocesador:
El microprocesador es el chip que se encarga de controlar, manejar y procesar los datos de un ordenador. Este lleva a cabo una gran variedad de cálculos, comparaciones numéricas y transferencias de datos como respuesta a las peticiones de los programas que están siendo ejecutados en memoria.
Para cuestiones de operaciones de cálculo y almacenamiento de datos, el procesador cuenta con una serie de REGISTROS que actúan como una variable, como un lugar de almacenamiento dentro del procesador en si, esto hace que la información almacenada en estos registros sea mas accesible que cualquier otra que tenga que pasar por algún bus de datos (también llamados “sendas electrónicas” transfieren datos por los dispositivos de entrada y salida E/S).
Registros de mayor relevancia:
------------------------------------------------de Datos
AX (Acumulator Register) ~ Acumulador
BX (Base Index Register) ~ Indice Base
CX (Counter Register) ~ Contador
DX (Data Register) ~ Dato
Uso: para cálculo y almacenamiento general de datos.
Observaciones: Cada uno de estos registros tiene una longitud de 16 bits, que por cuestiones de conveniencia puede dividirse en dos registros de 8 bits.
Pe.: El registro BX se puede dividir en BH (H ~ High ~ Alto) que se refiere al los 8 bits mas significativos (mas a la izquierda) y BL (L ~ Low ~ Bajo) que se refiere al los 8 bits menos significativos (mas a la derecha). Así seria: BX = BH + BL ~ 046Ch = 04h + 6Ch
------------------------------------------------de Índice
SI (Source Index) ~ Índice de Origen
DI (Destination Index) ~ Índice de Destino
BP (Base Pointer) ~ Puntero Base
SP (Stack Pointer) ~ Puntero de Pila
Uso: para direccionamientos de memoria.
Observaciones: no puede dividirse en dos registros separados.
------------------------------------------------de Instrucción:
IP (Instruction Pointer) ~ Puntero de Instrucción
Función: indica la dirección de la siguiente instrucción a ejecutar. Su valor cambia conforme a la ejecución de instrucción actual.
------------------------------------------------de Segmentos:
CS (Current Segment) ~ Segmento Actual (referido al programa cargado en la memoria)
DS (Data Segment) ~ Segmento de Datos
ES (Extra Segment) ~ Segmento Extra
SS (Snack Segment) ~ Segmento de Pila
Funcion: apuntan a un segmento (64ks de memoria).
------------------------------------------------Flags:
CF (Carry Flag) ~ Bandera de por acarreo
PF (Parity Flag) ~ Bandera de por paridad
AF (Auxiliary Flag) ~ Bandera Auxiliar
ZF (Zero Flag) ~ Bandera por cero
SF (Sing Flag) ~ Bandera de signo
TF (Trap Flag) ~ Bandera de paso simple
IF (Interrupt Flag) ~ Bandera de interrupción
DF (Direction Flag) ~ Bandera de dirección
OF (Overflow Flag) ~ Bandera de desbordamiento
Son registros donde se guardan los resultados de una comparación o de una operación matemática realizada. Estos registros solo almacenan los resultados de estado.
-Sistema de numeración:
En ASM, para identificar un numero decimal se le agrega una 'd' al final del numero (04=04d), aunque mayormente, si no se le agrega la “d” a un numero, el programa ensamblador lo identifica como decimal; mientras que en hexadecimal se le agrega una 'h' (04h).
Los números hexadecimales (con base 16), pueden estar formados por los dígitos: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E y F, con valores de 0d a 15d (0h - Fh).
--Convertir hexadecimal a decimal:
Para convertir un numero de hexadecimal a decimal, se multiplica el valor del primer digito por 16 elevado a la potencia 0, luego a eso se le suma el resultado de multiplicar el segundo digito de derecha a izquierda por 16 elevado a la potencia 1, y así sucesivamente con cada digito del numero a la potencia anterior mas uno.
Pe.: 43Ah = (10) + (3*16) + (4*162) + (0*163) = 10 + 48 + 1024 + 0 = 1082d.
*Si un número comienza por una letra, a este se le agrega un 0. Pe.: A32h = 0A32h
-Direccionamientos y posiciones de memoria:
Una posición de memoria se refiere a un byte específico dentro de esta, en ensamblador, estas posiciones se determinan mediante los registros (Pe. DS:SI).
Una direccion de memoria en ensamblador esta especificada un SEGMENT, seguido de “:” y un OFFSET. ((Pe.: DS->(segment):->(”:”)SI->(offset) ~ DS:SI.))
Supongamos que el registro DS tiene un valor de 0043h, y el SI un valor de 012Ah. Para saber a que byte especifico apunta la dirección DS:SI, se debe realizar la siguiente suma
DS ~ 0043
SI ~ + 012A
_______________
DS:SI ~ 0055Ah
-Uso de TASM para crear un ejecutable:
--Estructura del código fuente en el TASM:
Dentro del código se pueden añadir comentarios usando “;”
Pe.:
---------------------Inicio del código (comentario) *1
; Esto es un comentario dentro del código
---------------------Fin *1
---------------------Código explicativo de la estructura de un código fuente usando TASM. *1
.MODEL SMALL; Especifica el tipo de ejecutable que es.
.STACK 100H; Especifica el stack
.DATA; Aquí es para definir los datos
.CODE; Indica que desde aquí empieza el código
INICIO: ; Esta es una etiqueta, es un nombre que se le da a una posición para luego poder
; referirnos a ella por su nombre.
; Aquí entonces rellenamos con lo que queramos.
END INICIO; Aquí se le dice al ensamblador que el código termina. El nombre que va después ; del END debe ser el mismo de la etiqueta de inicio del código
---------------------Fin *1
*Nota: *1 quiere decir que dicha línea es solo parte de este tutorial, no se usa a la hora de programar.
--Algunas ordenes del ASM:
--La orden MOV ~ Move ~ Mover ((Pe1.: mov ax,04h))
Contiene dos parámetros. Su función es copiar el contenido del segundo parámetro al primero. Los parámetros pueden ser registros, valores específicos y posiciones de memoria. Existen excepciones en cuanto al tipo de parámetros que se utilicen. Por ejemplo, NO se le puede asignar un valor directamente a un registro de segmento, para hacer esto, primero se debe pasar el valor a transferir a un registro (que no sea de segmento, ya que no se puede transferir el contenido de un registro de segmento a otro de segmento), y luego asignar el valor de este registro al de segmento.
((Pe2.: MOV DS,0F6Ch ? esto NO es una orden valida. Para eso, se debe:
MOV DX,0F6Ch ;mover el valor al registro DX (DX es un ejemplo, podía haber sido cualquier ;otro (que no sea de segmento!))
MOV DS,DX ;mover el contenido de DX al DS ))
Otra excepción es que, NO se puede transferir el contenido de una posición de memoria a otra posición de memoria directamente, para hacerlo debe introducirse el contenido de una posición a un registro y luego entonces copiar el contenido de dicho registro a la otra posición de memoria.
((Pe3.: MOV DS:[3000],ES:[1020] ? esto NO es una orden valida. Para hacer esto, debemos:
MOV AX,ES:[1020] ;Aquí copiamos el contenido de ES:[1020] en AX
MOV DS:[3000],AX ;Luego lo movemos a DS:[3000]))
--La orden ADD ~ Sumar ((Pe.: add al,02h))
Contiene dos parámetros. Su función es sumar el valor del 2do parámetro al 1er parámetro.
(( add al,02h ~ al+=02h ~ al=al+02h )).
--La orden INC ~ Increment ~ Incrementar ((Pe.: inc di))
Contiene un solo parámetro. Su función es incrementar el valor del parámetro en 1.
(( inc di ~ di++ ~ di = di + 1 ))
--La orden CMP ~ Comparar ((Pe.: cmp ax,02Ah))
Contiene dos parámetros. Su función es comparar el valor de los dos parámetros.
--La orden JMP ~ Jump ~ Saltar ((Pe.: jmp etiqueta1))
Contiene un solo parámetro. Su función es saltar a otra posición de memoria o más bien dentro del código fuente se especifica el nombre de una etiqueta.
--La orden JE ~ Jump If Equal ~ Salta si es Igual ((Pe.: je etiqueta1))
Contiene un solo parámetro. Este es una orden condicional, depende de una comparación o del estado que de una flag. Su función es saltar a la etiqueta especificada, solo si la condición anterior daba un resultado que decía que los dos valores que se compararon son iguales.
--La orden JNE ~ Jump If Not Equal ~ Salta si no es Igual ((Pe.: jne etiqueta1))
Contiene un solo parámetro. Este es una orden condicional, depende de una comparación o del estado que de una flag. Su función es saltar a la etiqueta especificada, solo si la condición anterior daba un resultado que decía que los dos valores que se compararon no son iguales.
--La orden JZ ~ Jump If Zero ~ Salta si es cero ((Pe.: jz etiqueta1))
Contiene un solo parámetro. Este es una orden condicional, depende del estado que de una flag. Su función es saltar a la etiqueta especificada, solo si el registro correspondiente da un resultado igual a cero.
--La orden INT ~ Interruption ~ Interrupción ((Pe1.: int 21h))
Contiene un solo parámetro*2. Su función es ejecutar la interrupción especificada.
*2 Aunque esta orden contenga un solo parámetro, utiliza los valores almacenados en algunos registros específicos para cada interrupción. Cada interrupción tiene servicios diferentes. Estos servicios llevan como parámetros los valores que se le asignan anteriormente a algunos registros.
Pe2.:
----------------------------------Ejemplo del uso del servicio 3DH de la INT 21H (Crear un archivo)*1
…
;Parámetros:
;DS:DX = Apuntador al nombre del archivo ASCIIZ
;AL = Modo de acceso
; AL = 0 ~ lectura
; AL = 1 ~ escritura
; AL = 2 ~ lectura/escritura
;Devuelve CF y AX para el manejo de errores;
;Éxito ~ CF=0
; AX = descriptor o handle.
;Error ~ CF=1
; AX = código de error.
MOV DX,OFFSET ARCHIVO ;Apuntamos al offset de la “variable” ARCHIVO almacenandolo ;en DX
MOV AH,3DH ;Almacenamos el valor 3Dh en AH
MOV AL,2 ;Especificamos AL con el valor 2
INT 21H ;Ejecutamos la int
…
----------------------------------Fin*1
-Nuestro primer programa en ASM:
--Crear un programa que imprima en pantalla un clásico “HOLA MUNDO!” (También veremos el servicio 9 de la int 21h)
Lo primero que haremos es crear el código fuente:
-------------------------------HMundo.asm*1
.MODEL SMALL ; Determinamos el modelo de memoria
.STACK ; Definimos el área de pila
.DATA
MENS DB "HOLA MUNDO!.$" ; Especificamos la cadena de texto a mostrar
.CODE ; Inicio del código
INI: ; Etiqueta de inicio
MOV AX, @DATA ; Permite tener acceso a los datos
MOV DS,AX ; a través de el registro DS
MOV DX,OFFSET MENS ; Prepara para desplegar el mensaje
MOV AH,9 ; Llama al servicio 9
INT 21H ; de la int 21h para desplegar el texto
MOV AH,4CH ; Llama al servicio 4Ch
INT 21H ; de la int 21h para terminar
END INI ; Cierra la etiqueta de inicio
-------------------------------Fin*1
Luego que ya tenemos el código fuente, debemos ensamblar el código (teniendo el programa ensamblador, claro esta), para esto entramos al intérprete de comandos:
Luego nos posicionamos en la carpeta donde se encuentran los archivos del ensamblador (en mi caso: “D:\TASM\BIN”)
Luego usamos el TASM para ensamblar el código:
*Nota: si no se especifica, el codigo objeto (.obj) se guardara en la carpeta donde se encuentra el ensamblador.
Si no hay ningún error, continuamos. Ahora debemos “linkear” el código objeto, esto lo hacemos con TLINK:
*Nota: al igual que TASM, si no se especifica, TLINK guarda el ejecutable el la carpeta donde se encuentre el ensamblador.
Ahora, si no hay ningún error, solo resta probar el programa, esto lo podemos hacer mediante la misma consola, solo debemos escribir su nombre y oprimir ENTER:
Y listo. En la imagen se puede apreciar como aparece la cadena de texto “HOLA MUNDO!.”
--Utilización del comando DEBUG de Windows para probar programas:
Windows cuenta con una herramienta de edición y comprobación de programas, la cual podemos utilizar para probar programas antes de convertirlos en ejecutables. Una desventaja del debug, si así puede llamarse, es que a la hora de codificar el programa, no contamos con herramientas propias de un programa ensamblador, tales como la utilización de etiquetas, el uso de variables, etc. Todo lo debemos hacer mediante posiciones específicas de memoria.
---Comprobación del programa “HMUNDO” mediante debug:
Probaremos el programa, que hicimos anteriormente en TASM, con el comando debug.
----Comandos del debug que usaremos para probar el programa:
E ~ Enter ~ Introduce datos directamente en la posición de memoria especificada.
((Pe.: e 0f1e:0000 ‘Texto.$’)) ? este comando asigna la cadena de texto “Texto” en la posición de memoria 0f1e:0000
A ~ Assemble ~ Permite introducir el código de nuestro programa a partir de la dirección especificada.
((Pe.: a 1024)) ? este comando indica que el siguiente código se empezara a escribir desde el offset 1024 del actual segmento.
G ~ Go ? sin parámetros, comprueba la porción de código que se a introducido en la memoria, o a la posición que se apunte.
Q ~ Quit ? Salir de debug
--Comprobación del programa:
Abrimos el intérprete de comandos, y escribimos debug seguido de un ENTER
Lo primero que hay que saber es que en el programa (HMUNDO) tenemos un cadena de texto que tiene que ser asignada a una posición de memoria, como ya no se cuenta con los recursos del ensamblador, debemos asignar esa cadena de texto directamente a la memoria, esto lo hacemos con la ayuda del comando “e” del debug:
Luego mediante el comando “a” del debug, comenzamos a escribir el codigo del programa:
Ahora solo resta probarlo mediante el comando “g” del debug:
En la imagen se puede apreciar el mismo resultado obtenido mediante la creación del programa con TASM.
-Conclusión:
Este tutorial solo pretende ser una introducción a la majestuosidad de este lenguaje. Es imposible explicar la potencia del asm en pocas páginas.
*Nota: *1 se refiere a que dicha línea es solo parte de este tutorial, no se usa a la hora de programar.
“Pe.:” se refiere a un ejemplo explicativo. Pe.: ~ Por ejemplo
~: Se refiere al significado o a una equivalencia.
Autor