INGENIERÍA EN SISTEMAS

COMPUTACIONALES

EXAMEN GLOBAL DE

LENGUAJE ENSAMBLADOR

REPORTE DE PRACTICA No.1

INTRODUCCIÓN AL ENSAMBLADOR DEL 8086:

TURBOASSEMBLER

GERSÓN CRUZ GARCÍA, 096Z0059

ING. OSCAR LUIS PEÑA VALERIO

H. Y G. ALVARADO, VER. DICIEMBRE 2013

INSTITUTO TECNOLOGICO SUPERIOR DE

ALVARADO

OBJETIVO

Al terminar esta práctica, el alumno será capaz de:

Ensamblar un programa usando el ensamblador del 8086: Turbo Assembler. Conocer los

diferentes archivos generados por el ensamblador y el ligador.

INTRODUCCION

El Microprocesador, es un dispositivo que procesa la información contenida en memoria.

Esta información es una secuencia de números binarios que el microprocesador interpreta

como instrucciones codificadas y que en conjunto forman un programa. Este programa con

las instrucciones codificadas se denomina programa en Lenguaje Máquina o archivo

ejecutable.

Si una persona quisiera desarrollar un programa para un microprocesador se le dificultaría

mucho pensar las instrucciones en términos de números ya que ésta no es la forma natural

del pensamiento humano, por lo que es más conveniente pensar el programa en un

lenguaje simbólico llamado Ensamblador. En este lenguaje, una instrucción no está

representada por un número, sino que se representa por una palabra corta que nos dan

una idea muy clara de la instrucción que se trata, a esta palabra se le conoce como

Mnemónico. Un programa escrito en el lenguaje ensamblador se llama programa fuente.

Cada microprocesador tiene su propio lenguaje ensamblador. Para traducir un programa

fuente escrito en lenguaje ensamblador a su correspondiente programa en lenguaje

máquina se necesita un programa traductor llamado Ensamblador. El proceso de

traducción se conoce como ensamblado.

Uno de los ensambladores comerciales para la familia de microprocesadores 80x86 es el

programa Turbo Assembler de la compañía Borland International. Turbo Assembler es un

macroensamblador ya que adicionalmente tiene un preprocesador que le permite ejecutar

directivas de inclusión y expansión de macros.

Al ensamblar un programa, Turbo Assembler procesa el programa fuente y genera un

archivo objeto el cual está formado por los códigos de las instrucciones. Sin embargo, este

programa aún no está listo para correr, es decir, este archivo no es ejecutable ya que sus

direcciones están representadas en forma relativa. Este archivo es un archivo binario.

Turbo Assembler además de generar el archivo objeto, genera un archivo texto en el que

aparece el listado del programa fuente y su equivalente en códigos numéricos o código

máquina. En este archivo podemos verificar la forma en que fue ensamblado el programa

fuente.

Una vez que se tiene el programa objeto este se puede convertir en programa ejecutable

usando un programa ligador. Un programa ligador le agrega al código objeto la información

necesaria para que el programa sea ejecutable, asimismo si el programa consta de varios

módulos y/o contiene llamadas a subrutinas que se encuentren en una biblioteca, el ligador

establece las ligas entre el código de esos módulos y bibliotecas.

El programa ligador de Turbo Assembler se llama Tlink. Tlink también genera un archivo

texto en el que se detallan las direcciones y tamaños que ocupan cada uno de los

segmentos e instrucciones del programa ejecutable.

PASOS PARA EL DESARROLLO DE LA PRÁCTICA

1.- Abra una ventada de CMD oprimiendo las teclas + la tecla R, saldrá una

ventana como la siguiente:

Escriba CMD y presione enter o de clic en aceptar, después de eso aparecerá la siguiente

ventana:

2.- Verifique que entre el listado de directorios reconocidos por el sistema se encuentren

las direcciones C:\TC y C:\TASM escribiendo el comando PATH y tecleando enter

Inmediatamente aparecerá la lista de directorios reconocidos por el sistema, si los dos

directorios mencionados anteriormente se encuentran en la lista pase directamente al paso

numero 8; de lo contrario continúe con los pasos siguientes.

3.- Al no aparecer los directorios en la lista habrá que añadirlos manualmente a la lista.

4.- Presione la tecla de inicio + la tecla PAUSA, aparecerá la siguiente ventana:

Busque la opción de “Configuración avanzada del sistema” y dele clic:

5.- Presione el botón “Variables de entorno…”, en la ventana que aparece, ubique la sección de

“Variables del sistema”, seleccione la variable “path” y presione el botón “Editar…”.

6.- Valla al final del cuadro de texto “Valor de la variable:” y añada las siguientes rutas:

C:\TASM\BIN; C:\TC\BIN;

Cierre todos los cuadros de dialogo presionando el botón aceptar de cada uno.

7.- Ejecute nuevamente la ventana de CMD, y teclee de nuevo el comando:

Path

Deben de aparecer las rutas que se capturaron anteriormente y para verificar que el acceso a los

programas es correcto, teclee lo que se muestra a continuación:

Escriba en la ventana ms-Dos tcc y pulse enter, el resultado debe ser el siguiente.

Escriba en la ventana ms-Dos tasm y pulse enter, el resultado debe ser el siguiente.

8.- Cree una carpeta de trabajo en la unidad disco C: con el nombre de “cls

”, en esta carpeta irás creando otras según los nombres de los ejercicios que se vayan realizando:

9.- Cree una carpeta con el nombre de “Primer” dentro de la carpeta “Prog_Ensamblador”, y abra

una ventana CMD y cambie la ubicación del directorio a esa carpeta aplicando el siguiente comando:

cd C:\Prog_Ensamblador\Primer

y teclee enter, el cambio se notara, después de eso teclee:

tc, pulse enter

10.- Teclee el siguiente programa fuente en el lenguaje ensamblador y grábelo en su carpeta de

trabajo con el nombre PRIMER.ASM:

;**********************************************************

; PRIMER.ASM.

;

; Este programa ilustra la estructura de un programa en

; ensamblador. También muestra las principales directivas

; para el ensamblador.

;**********************************************************

;****** CÓDIGO DE INICIO **********************************

ideal

model small

stack 256

;****** DECLARACIÓN DE CONSTANTES SIMBÓLICAS **************

cte equ 10

;****** VARIABLES DEL PROGRAMA ****************************

dataseg

codsal db 0

dato1 db ?

dato2 db ?

resul db ?

;****** CÓDIGO DEL PROGRAMA *******************************

codeseg

inicio:

mov ax, @data ; Inicializa el

mov ds, ax ; segmento de datos

mov al, [dato1] ; resul = dato1 + dato2 +

add al, [dato2] ; cte

add al, cte

mov [resul], al

salir:

mov ah, 04Ch

mov al, [codsal]

int 21h

;****** CÓDIGO DE TERMINACIÓN *****************************

end inicio

11.- Salga del programa Turbo C-

12.- Ensamble el programa PRIMER.ASM tecleando:

tasm /l /zi PRIMER.ASM

Turbo Assembler comenzará a ensamblar al programa desplegando:

13.- Use el comando DIR para observar los archivos generados por el programa Turbo Assembler,

tecleando:

dir

Estos son:

primer.obj

primer.lst

Utilice el editor de Turbo C para examinar el contenido del archivo PRIMER.LST. En la pantalla del

editor aparecerá lo siguiente:

Observe que del lado derecho de la pantalla aparece el código fuente. El número de línea aparece a

la izquierda seguido de la dirección relativa donde estará almacenada la instrucción o dato y

posteriormente el código de la instrucción.

Por ejemplo, la línea 24:

17 0001 ?? dato1 db ?

Aquí la directiva db reserva un byte de memoria en la localidad 0001h del segmento de datos y se

le ha asignado el símbolo dato1. El número 17 es el número de línea en la que se encuentra esta

directiva en el programa fuente. El valor de 0001 es la dirección reservada para la variable dato1, ??

significa que la variable no ha sido inicializada. Compare esta línea con la línea 23 en la que la

variable codesal está inicializada a 0.

La línea:

25 0005 A0 0001r mov al, [dato1] ; resul = dato1 + dato2 +

Muestra el formato generado por el ensamblador para una instrucción. El primer número

corresponde a la línea en la que se encuentra esta instrucción en el programa fuente. Enseguida

aparece la dirección en la que será almacenado el código. Después aparece el código de la

instrucción. Note que los comentarios al final de la línea no producen código.

14.- Salga del editor de Turbo C.

15.- Para convertir el programa objeto en un programa ejecutable usaremos el programa TLINK.EXE,

tecleando:

tlink /v /m /s /l primer

TLink empezará a convertir el programa desplegando lo siguiente:

16. Use el comando DIR para observar los archivos generados por el programa TLink, tecleando:

dir

Estos son:

primer.map

primer.exe

17.- Utilice el editor de Turbo C para examinar el contenido del archivo PRIMER.MAP. En la pantalla

del editor aparecerá lo siguiente:

Este archivo nos muestra cómo están distribuidos los segmentos a lo largo del mapa de memoria.

Este archivo es utilizado por algunos depuradores para mostrar las etiquetas y nombres simbólicos

al depurar un programa. De otra manera sólo mostraría sus valores numéricos.

18.- Cargue en el editor de Turbo C el programa fuente PRIMER.ASM y modifique la línea 30 para

que en lugar de tener la instrucción:

mov al, [dato1] ; resul = dato1 + dato2 + cte

se tenga un error de sintaxis:

mob al, [dato1] ; resul = dato1 + dato2 + cte

Grabe el programa y salga del editor.