Introducción al Entorno de Programación

Digital II
Introducción al entorno de
Programación
Departamento de Sistemas e Informática
Escuela de Electrónica
Facultad de Ciencias Exactas Ingeniería y Agrimensura
Universidad Nacional de Rosario
Diego Alegrechi
Andrés Capalbo
2000
INTRODUCCIÓN
AL ENTORNO DE PROGRAMACIÓN
CONTENIDO:
I N T R O D U C C I Ó N A L E N T O R N O D E P R O G R A M A C I Ó N .................. 3
LOS TRADUCTORES DE LENGUAJES .......................................................................................... 3
COMPILADORES ....................................................................................................................... 3
EL PROCESO DE CONSTRUCCIÓN DE UN ARCHIVO EJECUTABLE ............................................... 4
ENSAMBLADOR (ASSEMBLER)................................................................................................. 5
ENLAZADOR (LINKER)............................................................................................................. 5
ENTORNO MICROSOFT PROGRAMMER'S WORKBENCH (PWB) .......... 6
CREACIÓN DEL CÓDIGO FUENTE .............................................................................................. 6
CONSTRUCCIÓN DE UN MÓDULO SIMPLE................................................ 7
ELECCIÓN DE LAS OPCIONES DE CONSTRUCCIÓN (BUILD OPTIONS) ......................................... 7
ELECCIÓN DE LA PLANTILLA DE PROYECTO (PROJECT TEMPLATE) PARA UNO.ASM .................. 7
ELECCIÓN DE LAS OPCIONES DE CONSTRUCCIÓN (BUILD OPTIONS).......................................... 8
CONSTRUCCIÓN DEL PROGRAMA ........................................................................................... 10
CORRECCIÓN DE ERRORES ..................................................................................................... 10
PROGRAMAS MULTIMÓDULOS .................................................................. 11
CREACIÓN DE UN PROYECTO.................................................................................................. 11
DEPURACIÓN DEL PROGRAMA .................................................................. 12
EJECUCIÓN PASO A PASO........................................................................................................ 13
EJECUCIÓN CON PUNTOS DE PARADA (BREAKPOINTS)............................................................ 13
MANEJO DE LA VENTANA DE MEMORIA ................................................................................. 13
BIBLIOGRAFÍA ................................................................................................ 13
Autores: Alegrechi-Capalbo
Versión 2000
Página 2 de 13
INTRODUCCIÓN
INTRODUCCIÓN
AL ENTORNO DE PROGRAMACIÓN
A L E N TO R N O D E P R O G R A M A C I Ó N
Este apunte está destinado a servir de texto auxiliar a los alumnos de DIGITAL II para
la realización del trabajo práctico de programación en ASSEMBLER. Su objetivo es
desarrollar la comprensión de ideas básicas sobre el manejo del entorno de programación. No
se tratarán los temas correspondientes al lenguaje de programación propiamente dicho, los
cuales ya fueron abordados en otros apuntes de la cátedra.
En la primera parte se realiza una introducción a los procesos involucrados en la
generación de un archivo ejecutable partiendo de un código fuente (Assembler).
En la segunda parte se explica paso por paso el manejo del entorno de trabajo, para la
generación y depuración de programas simples.
Los traductores de lenguajes
Para poder describir los programas escritos en un lenguaje de programación y que
posteriormente puedan ser entendidos por la computadora, se requieren traductores de
lenguajes. Tradicionalmente los traductores se dividen es dos clases: intérpretes (Ej: Basic) y
compiladores (Ej: C, C++).
Un intérprete traduce cada sentencia del código fuente (escrito en el lenguaje de
programación) en instrucciones en código máquina que son ejecutadas inmediatamente.
Un compilador traduce todo el código fuente directamente en instrucciones máquina,
denominado código objeto. Los programas generados por un compilador tienden a requerir
mucho menos espacio para su ejecución y se ejecutan mucho más rápidamente que los
interpretados.
Compiladores
Dentro de los lenguajes de programación que pueden compilarse existen los de alto
nivel y los de bajo nivel. Los programadores que escriben en un lenguaje de alto nivel, como
C y Pascal, codifican comandos poderosos, cada uno de los cuales puede generar muchas
instrucciones en lenguaje de máquina. Por otro lado, los programadores que escriben en un
lenguaje Assembler, de bajo nivel, codifican instrucciones simbólicas, cada una de las cuales
genera una instrucción en lenguaje de máquina. A pesar del hecho de que codificar en un
lenguaje de alto nivel es más productivo, programar en lenguaje Assembler tiene algunas
ventajas que a continuación se detallan:
! Proporciona más control sobre el manejo particular de los requerimientos de hardware.
! Genera módulos ejecutables más pequeños y más compactos.
! Con mayor probabilidad tiene una ejecución más rápida.
Como desventaja, escribir un programa en lenguaje Assembler requiere conocimientos
acerca del Hardware (arquitectura) de la computadora, su conjunto de instrucciones y sus
reglas de uso.
Una práctica común es combinar los beneficios de ambos niveles de programación, se
puede codificar el grueso de un proyecto en un lenguaje de alto nivel y los módulos críticos
(aquellos que provocan notables retardos) en lenguaje Assembler.
Sin importar el lenguaje de programación que utilice, de todos modos es un lenguaje
simbólico que tiene que traducirse a una forma que la computadora pueda ejecutar. Un
lenguaje de alto nivel utiliza un compilador para traducir el código fuente a lenguaje de
Autores: Alegrechi-Capalbo
Versión 2000
Página 3 de 13
INTRODUCCIÓN AL ENTORNO DE PROGRAMACIÓN
máquina (técnicamente, código objeto). Un lenguaje de bajo nivel utiliza un ensamblador
para realizar la traducción al lenguaje de máquina. Observemos que el compilador y el
ensamblador llegan al mismo resultado (archivo objeto .OBJ), pero el primero deberá realizar
tareas extras dado que el lenguaje a convertir es de alto nivel. De aquí en adelante nos
referiremos en forma indistinta a los términos compilador y ensamblador.
Un programa enlazador para ambos niveles, alto y bajo, completa el proceso al
convertir el código objeto en lenguaje ejecutable de máquina.
Los archivos objeto permiten tratar programas independientes que se combinan
eventualmente en un programa ejecutable mediante el linker. Este proceso se denomina
compilación separada.
Archivo Fuente 1
(.ASM)
Ensamblador
Archivo Objeto 1
(.OBJ)
Archivo Fuente 2
(.ASM)
Ensamblador
Archivo Objeto 2
(.OBJ)
Linker
Archivo Ejecutable
(.EXE) (.COM)
Archivo Objeto 3
(.OBJ)
La compilación separada tiene numerosos beneficios. Un programa grande se puede
dividir en diferentes piezas o módulos, cada uno de los cuales se pueden construir y
comprobar independientemente.
El Proceso de Construcción de un archivo ejecutable
La creación y ejecución un archivo involucra tres pasos:
1. Ensamblar (Assembling): consiste en la traducción del código fuente en código objeto y
la generación de un archivo intermedio .OBJ (objeto), o módulo. Una de las tareas del
ensamblador es calcular el desplazamiento de cada elemento en el segmento de datos y de
cada instrucción en el segmento de código. El ensamblador también crea un encabezado al
frente del módulo .OBJ generado; parte del encabezado tiene información acerca de
direcciones incompletas. El módulo .OBJ aún no está en forma ejecutable.
2. Enlazar (Linking): implica convertir el módulo .OBJ en un módulo de código de máquina
.EXE (ejecutable). Una de las tareas del enlazador es combinar los programas
ensamblados en forma separada en un módulo ejecutable.
3. Carga (Loading): El último paso es cargar el programa para su ejecución. Ya que el
"cargador" (Sistema Operativo) conoce en dónde está el programa a punto de ser cargado,
puede completar las direcciones indicadas en el encabezado que estaban incompletas. El
cargador desecha el encabezado y crea un PSP (prefijo del segmento del programa)
inmediatamente antes del programa cargado en memoria.
Autores: Alegrechi-Capalbo
Versión 2000
Página 4 de 13
INTRODUCCIÓN AL ENTORNO DE PROGRAMACIÓN
Ensamblador (Assembler)
Muchos ensambladores dan dos pasadas al programa fuente a fin de resolver
referencias hacia adelante (o posteriores) a direcciones que aún no se encuentran en el
programa. Durante la pasada 1, el ensamblador lee todo el código fuente y construye una tabla
de símbolos de nombres y etiquetas usadas en el programa, esto es, nombres de campos de
datos y etiquetas del programa y sus localidades relativas (desplazamiento) dentro del
segmento.
La pasada 1 determina la cantidad de código que es generado por cada instrucción y se
inicia la generación del código objeto.
Durante la pasada 2, el ensamblador usa la tabla de símbolos que construyó en la
pasada 1. Ahora que "conoce" la longitud y posiciones relativas de cada campo de datos e
instrucción, puede completar el código objeto para cada instrucción. Después produce, si se lo
solicita, los diferentes archivos: objeto (.OBJ), de listado (.LST) y de referencias cruzadas
(.REF).
Enlazador (Linker)
El enlazador realiza las funciones siguientes:
! Si se pide, combina más de un módulo ensamblado de forma separada en un programa
ejecutable, como dos o más programas en ensamblador o un programa en ensamblador con
un programa en C.
! Genera un módulo .EXE y lo inicializa con instrucciones especiales para facilitar su
subsecuente carga para ejecución.
Una vez que se ha enlazado uno o más módulos .OBJ en un módulo .EXE, se puede
ejecutar el módulo .EXE cualquier número de veces. Pero siempre que se necesite realizar un
cambio al programa, debe corregirse el programa fuente, ensamblarlo en otro módulo .OBJ y
enlazar el módulo .OBJ en un módulo .EXE.
Autores: Alegrechi-Capalbo
Versión 2000
Página 5 de 13
INTRODUCCIÓN
AL ENTORNO DE PROGRAMACIÓN
ENTORNO MICROSOFT PROGRAMMER'S WORKBENCH (PWB)
El entorno es un sistema de desarrollo completamente integrado que contiene los
siguientes componentes:
! Un editor para escribir y revisar programas.
! Un "build engine" (motor de construcción), que es el componente que se encarga de
ensamblar, linkeditar y ejecutar programas en forma automática.
! Navegador de código fuente.
! Comandos para ejecución y depuración (debugging) de programas.
! Sistema de ayudas
En el editor se cuenta con las opciones clásicas de todo editor de texto, como ser de
archivo, nuevo, abrir, guardar, salir, etc.. y de edición, cortar, copiar, pegar, etc...
PWB utiliza un entorno de ventanas para presentar y requerir información.
En la siguiente figura se observa algunas partes del entorno:
Creación del código fuente
Como ejemplo proponemos el
siguiente programa que contiene errores
introducidos en forma intencional para ver el
proceso de depuración del mismo. Para
comenzar simplemente es necesario crear un
archivo nuevo, tipear el programa y guardarlo
con el formato nombre.asm como por ejemplo
"uno.asm " .
Autores: Alegrechi-Capalbo
.MODEL small
.STACK
.DATA
.CODE
.STARTUP
mov ax,6 ;Carga ax=6
add 3,ax ;Resuelve ax = ax + 3
.EXIT
END
Versión 2000
Página 6 de 13
INTRODUCCIÓN
AL ENTORNO DE PROGRAMACIÓN
Construcción de un módulo simple
En PWB el ensamblado y linkeditado de un archivo fuente es llamado construcción
(building the project).
Elección de las opciones de construcción (Build Options)
Antes de realizar la construcción del programa se debe especificar que clase de archivo
será creado. Mediante el uso del menú Opciones se puede elegir:
! El "Run time support". Esto es importante para desarrollo con varios lenguajes de
programación simultáneamente, donde se tiene algún archivo fuente en assembler y
algunos en otros lenguajes. En nuestro caso deberemos escoger la opción ASSEMBLER.
! La Plantilla de proyecto (Project template). La plantilla describe en detalle como debe ser
construído el proyecto indicando el tipo de archivo (.EXE, .COM, .DLL, .LIB ) y detalla
en que sistema operativo correrá el programa.
! Construcción de depuración o de versión final (Debug o Release build). Cuando se escoge
la opción Debug (depurar) normalmente se especifica que se incluya información para
poder ver el código fuente mientras se depura el programa (Code View), lo que no es
necesario para la versión final dado que se supone que no será necesaria la verificación del
programa. Además se podrán generar archivos con listados de los resultados de la
construcción (compilación y linkedición).
Estas opciones son útiles en el proceso de desarrollo del programa. En la primera fase es
conveniente trabajar en modo depuración (Debug), con el fin de arribar a una versión final
optimizada. En una segunda y última fase, se utilizan las opciones correspondientes a la
versión final (Release build) del programa.
Elección de la plantilla de proyecto (Project template) para uno.asm
1. Del menú Options, elegir Project template y luego Set project template
Autores: Alegrechi-Capalbo
Versión 2000
Página 7 de 13
INTRODUCCIÓN
2. PWB mostrará la pantalla:
AL ENTORNO DE PROGRAMACIÓN
Generalmente en la lista Run time support figura como opciones None y Assembler. Si
tiene instalado otros lenguajes de programación aparecerán en dicha lista. (elegir Assembler)
3. En la ventana Templates elegir DOS.EXE y aceptar.
Elección de las opciones de construcción (Build options)
1. En el menú Options elegir Build options
2. Optar por las opciones para depuración (Use debug options). De esta manera, PWB
utilizará las opciones de depuración cada vez que se construya (Build) el programa.
3. Del menú Options elegir Languages options y luego MASM Options seguido a esto hacer
click en Set debug options.
Autores: Alegrechi-Capalbo
Versión 2000
Página 8 de 13
INTRODUCCIÓN AL ENTORNO DE PROGRAMACIÓN
4. En este menú se debe escoger en la sección de Debug information CodeView.
5. Si se desea generar un archivo de resultados de la compilación, en la sección Listing se
debe seleccionar Generate listing file y luego las opciones deseadas. En la figura se
observan las recomendadas.
6. Si se desea generar un archivo de resultados de la Linkedición, en el menú Options,
seleccionar Link Options, y luego Additional Debug Options.
7. En la sección Map File hacer la opción deseada.
Autores: Alegrechi-Capalbo
Versión 2000
Página 9 de 13
INTRODUCCIÓN AL ENTORNO DE PROGRAMACIÓN
PWB salva las opciones especificadas. No es necesario especificarlas cada vez que se
trabaje con el proyecto. Las opciones globales son utilizadas en cada construcción (Build).
Las opciones para depuración son utilizadas cuando esté seteada la opción use debug options.
De lo contrario se utilizan las opciones para la versión final del programa (release options).
Las opciones globales típicamente incluyen opciones tales como, nivel de detección de errores
(warning level), modelo de memoria, etc.
El menú Options contiene más comandos que permiten describir las opciones de
construcción del proyecto en una forma más detallada. No es necesario cambiar la mayoría de
las opciones para construir un programa simple dado que los valores por defecto provistos por
la plantilla funcionan en forma correcta.
Construcción del programa
Una vez seteadas las opciones, puede construirse el programa.
En el menú Project elegir Build. Si las opciones de construcción han sido cambiadas,
PWB preguntará si se desea reconstruir todo (Rebuild all). Para el ejemplo
planteado(uno.asm), el resultado de la compilación es el siguiente:
Ahora tenemos las siguientes opciones:
! Ver los resultados completos de la construcción (View Result).
! Se puede correr o depurar el programa si este fue construido en forma satisfactoria (Sin
Errores).
! Pedir ayuda o Cancelar y volver al modo edición.
Corrección de errores
Para cada construcción, PWB muestra en Build result window una lista de los errores y
mensajes de la construcción. Como vemos el ejemplo tiene algunos errores. Para examinar
los errores de construcción, en la ventana antes mencionada, colocando el cursor sobre
cualquiera de los errores y eligiendo del menú Projet, Goto error PWB abre la ventana de
código fuente correspondiente y pone el cursor en la línea en donde se encontró error.
Luego de corregirlo podremos volver a la ventana Build result window a través del
menú window. Si se desea realizar una corrección más rápida se puede ir de error en error
presionando SHIFT+F3 (Menú Project y Next error).
Autores: Alegrechi-Capalbo
Versión 2000
Página 10 de 13
INTRODUCCIÓN AL ENTORNO DE PROGRAMACIÓN
En nuestro ejemplo los resultados de la construcción fueron:
El primer error es debido a que la instrucción add no admite este formato. La forma
correcta es: add ax,3
El segundo error depende del primero, por lo tanto ya estamos en condiciones de
construir nuevamente el programa.
Programas Multimódulos
Cuando los programas crecen demasiado en tamaño y complejidad o es necesario
reutilizar programas previamente hechos (librerías por ejemplo), resulta conveniente trabajar
en forma modular y para esto es necesario un archivo que contenga información de cómo se
vinculan tales módulos. Este archivo es llamado Proyecto (Project).
PWB ofrece un modo eficiente de manejar proyectos complejos.
Creación de un proyecto
1. En el menú Project elegir New project, PWB mostrará:
2. Escribir el nombre del proyecto, el cual se guardará con extensión .mak
3. En la misma pantalla elegir setear la plantilla de proyecto (Set Project Template) y
realizarlo como fue explicado anteriormente (pag. 6).
4. En el siguiente paso PWB mostrará la pantalla de edición de proyecto (edit project dialog
box) donde se podrán agregar o quitar módulos al proyecto.
Autores: Alegrechi-Capalbo
Versión 2000
Página 11 de 13
INTRODUCCIÓN
AL ENTORNO DE PROGRAMACIÓN
Un proyecto, podrá contener archivos de tipo: *.ASM, *.OBJ, *.LIB, *.DEF, *.RC .
5. Una vez que se hallan agregado los módulos necesarios se deberá salvar la lista (Save List)
6. El proceso de construcción y corrección de errores es el mismo que para un programa de
módulo único.
7. Si es necesario agregar o quitar módulos al proyecto, esto puede realizarse desde el menú
Project, y luego Edit Project.
Depuración del programa
PWB integra muchas herramientas, entre ellas se encuentra una que permite la
depuración del programa DEBUGGER.
Para acceder a este programa se podrá hacer desde el menú Run y luego Debug, o bien
luego de la construcción en la ventana de resultados elegir Debug Program. Cabe destacar
que la opción Debug solo estará disponible si la construcción no arrojó errores.
El entorno de este programa tiene el siguiente aspecto:
Autores: Alegrechi-Capalbo
Versión 2000
Página 12 de 13
INTRODUCCIÓN AL ENTORNO DE PROGRAMACIÓN
Se observan tres ventanas:
! Source1: contiene el código fuente. Esta información puede ser presentada de tres formas
distintas: código fuente, código fuente y Assembler intercalados o solo Assembler. Estas
opciones se pueden escoger en el menú Options y luego Source1 Window...
! Memory1: muestra el contenido de la memoria. Las dos primeras columnas
corresponden a la dirección del primer elemento de la fila de datos, expresada en el
formato (Segmento:Desplazamiento). Los datos pueden visualizarse en distintos formatos
Byte, ASCII, Entero (por ejemplo). Estas opciones se pueden escoger en el menú Options
y luego Memory1 Window...
! Reg: muestra los valores actuales de los registros del microprocesador y las banderas
(Flags).
Luego de la ejecución de cada instrucción PWB resalta automáticamente los registros,
flags y/o posiciones de memoria que hallan cambiado su valor en dicho paso.
El entorno de trabajo se puede configurar a gusto, dependiendo de la forma de trabajo
del programador y del trabajo que se esté realizando. Desde el menú windows pueden agregar
o quitarse ventanas. La configuración de ventanas de la figura anterior es la más usual.
Ejecución paso a paso
Existen varias maneras para controlar y examinar la ejecución de un programa. El
comando Step (F10) ejecuta la instrucción siguiente en el programa, y si esta instrucción es
una llamada a procedimiento, lo ejecuta completamente en un solo paso. Por el contrario, el
comando Trace (F8) salta dentro del procedimiento y ejecuta cada instrucción paso a paso. Al
ejecutar cada paso se puede observar como se actualizan los valores de los registros, flags,
variables y memoria.
Ejecución con puntos de parada (breakpoints)
Se pude ejecutar un programa sin detenciones hasta un punto, llamado breakpoint.
Para definir un breakpoint primero nos situamos sobre la instrucción en la que se desea
detener el programa, y luego en el menú Data elegir Set breakpoint..., posteriormente escoger
la opción deseada y aceptar. Si se desea eliminar o cambiar los parámetros de un breakpoint
esto puede realizarse desde el menú Data y luego Edit breakpoint. Una forma más rápida y
sencilla de ejecutar un programa hasta un punto dado, es: una vez situado en dicho punto,
presionar F7 o el botón derecho del mouse (se ejecutará hasta dicha línea sin incluirla).
Manejo de la ventana de memoria
El programa nos permite observar lo que sucede en las locaciones de memoria y como
cambia mientras se ejecuta el programa. Con la barra de desplazamiento nos podemos
desplazar en la ventana de memoria hasta la posición deseada, pero una forma más práctica de
realizarlo es desde el menú Options seleccionando Memory1 Windows poner por ejemplo
DS:0 en el campo Address Expression (esto muestra el contenido de la memoria a partir del
comienzo del segmento de datos). Otra forma de realizarlo es parado sobre la ventana de
memoria, escribir en forma directa la posición de memoria deseada respetando el formato
segmento:desplazamiento.
Bibliografía
1. Environment and tools (Microsoft) "Mike Eddy"
2. Lenguaje ensamblador y programación para PC IBM® y compatibles (Pearson
Educación) "Peter Abel" Tercera Edición
3. Los microprocesadores INTEL (Prentice Hall) "Barry B. Bray" Tercera Edición
Autores: Alegrechi-Capalbo
Versión 2000
Página 13 de 13