Práctica 0. Introducción

Metodologíade diseño

Programación modular
Proceso de ensamblaje
Enlace y reubicación

Programaciónen ensamblador: entorno Turbo Assembler y Turbo Debugger

Análisisde un programa en ensamblador

Ejercicio propuesto

Metodologíade diseño

Programación modular

A la hora de desarrollar un programa pequeño, cualquier metodologíapuede valer. El problema surge cuando ese programa va creciendo, con loque la cantidad de sentencias lo hace poco legible y ya no es posible hacerun seguimiento lógico de su ejecución. Otro factor a teneren cuenta, es que la persona que lea un código no tiene porquéser la misma que lo ha escrito. Aún más, es posible que seandiferentes programadores los que intervengan en el desarrollo de una aplicación.

Parece claro que la solución pasa por la formulación deprogramas complejos a partir de secuencias pequeñas, o módulos,cada uno de los cuales realiza una tarea bien definida. Es lo que se denominauna programación modular.

Pero la modularidad no sólo debe estar presente en el código,debe estarlo en todo el desarrollo, a través de las siguientes tareas:

Especificación precisa de lo que tiene que hacer el programa.
División del problema global en tareas.
Definición exacta de lo debe hacer cada tarea y de cómo tienenque comunicarse entre sí.
Escritura de las tareas en lenguaje ensamblador y conexión de losmódulos para formar el programa.
Depuración y comprobación del programa.
Documentación del programa.

La principal ayuda utilizada para la división del programa en móduloses el diagrama jerárquico, que es una figura orientada a bloquesque resume las relaciones entre los módulos (tareas) y submódulos(subtareas). El diagrama jerárquico muestra la cadena de subordinacionesque existen entre los módulos y submódulos. Es una gran ayudatanto para el programador como para cualquier otra persona que quiera analizarel programa, ya que permite ver de forma clara su estructura funcional.

Las razones para dividir un programa en partes más pequeñaspueden ser:

Los módulos son más sencillos de comprender.
Se pueden asignar diferentes módulos a programadores distintos.
La depuración y la comprobación pueden realizarse de unaforma más ordenada.
La documentación puede comprenderse más fácilmente.
Las modificaciones pueden localizarse.
Las tareas de uso más frecuente pueden programarse como módulosque se almacenan en librerías para ser utilizados por varios programas.

Cuando se diseñan los módulos de un programa debe tenerseen cuenta cómo se entra y se sale de él, acoplamiento decontrol, y la forma en que se comunica la información entre ellos,o acoplamiento de los datos. En general, la selección tareas y eldiseño de los módulos deberían ser tales que resultesimple el acoplamiento de control y minimice el acoplamiento de los datos.

La mayoría de los ensambladores están diseñadospara ayudar en el proceso de modularización en tres formas, básicamente:

Permitir que los datos estén estructuradosde forma que puedan ser accedidos por varios módulos.
Proporcionar mecanismos del tipo procedimientoso subrutinas.
Permitir la inserción de secciones de código, conocidas comomacros,mediante la utilización de sentencias sencillas.

Proceso de ensamblaje

Un ensamblador es el programa que convierte un listado de códigofuente en código objeto, es decir, lenguaje máquina (el quefinalmente interpretará el procesador) en el que sólo lefaltan las referencias a rutinas externas. El código fuente es unfichero que contiene la secuencia de instrucciones en lenguaje ensambladorque forma el programa, así como ciertas directivas o comandos parael propio ensamblador, que ha sido creado utilizando un editor de texto.El código objeto consta del código en lenguaje máquinay de la información necesaria para enlazarlo con otros módulosobjeto.

Entrada y salida del ensamblador

Enlace y reubicación

Al construir un programa algunos de sus módulos pueden colocarseen el mismo módulo fuente y ensamblarse juntos, otros pueden estaren módulos diferentes y ser ensamblados separadamente. Si se ensamblanpor separado, el módulo principal, que contiene la primera instrucciónque se va a ejecutar, debe acabar con una sentencia END que indique elpunto de entrada al programa, y cada uno de los otros módulos debenterminar con una sentencia END sin ningún operando. En cualquiercaso, los módulos objeto resultantes, algunos de los cuales puedenestar agrupados en librerías, deben ser enlazados para formar elmódulo de carga, antes de que se pueda ejecutar el programa. Ademásde dar como salida el módulo de carga, el linker o enlazadorimprime un mapa de memoria que indica donde serán cargados los módulosobjeto en la memoria. Después de crearse el módulo de carga,éste es cargado por el cargador en la memoria del ordenador y comienzala ejecución.

La siguiente figura muestra el procedimiento general para la creacióny ejecución de un programa:

Independientemente del sistema, la combinación linker/cargadordebe crear todos los segmentos y asignaciones de dirección necesariospara permitirle al programa funcionar correctamente. En concreto, estacombinación debe:

Encontrar los módulos que van a ser enlazados
Construir el módulo de carga asignando las posiciones de todos lossegmentos de todos los módulos objeto que se están enlazando.
Rellenar todos los desplazamientos de segmento que no pudieron ser determinadospor el ensamblador.
Rellenar todas las direcciones de los segmentos.
Cargar el programa para su ejecución.

Programaciónen ensamblador: entorno Turbo Assembler y Turbo Debugger

Para realizar un programa que se ejecute en un PC, hay que partir deun fichero fuente en ensamblador, escrito con un editor de texto, que generecódigos ASCII, tal como EDIT.

El programa fuente que a continuación se lista se denomina FACTOR.ASM.

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

; CALCULA EL PRODUCTO DEL FACTORIAL DE DOS NUMEROS QUESE
; ENCUENTRAN EN LAS POSICIONES DE MEMORIA 0 Y 1 DEL SEGMENTODE
; DATOS. EL VALOR DE CADA NUMERO DEBE SER INFERIOR A9. EL RESULTADO
; SE ALMACENA EN DOS PALABRAS DEL SEGMENTO EXTRA, ENLA PRIMERA
; PALABRA EL MENOS SIGNIFICATIVO Y EN LA SEGUNDA EL MAS
; SIGNIFICATIVO. SE UTILIZA UNA RUTINA PARA CALCULAREL FACTORIAL.
;_______________________________________________________________________
;_______________________________________________________________________
; DEFINICION DEL SEGMENTO DE DATOS

DATOS SEGMENT

DATO_1 DB 0
DATO_2 DB 0

DATOS ENDS
;_______________________________________________________________________
;_______________________________________________________________________

; DEFINICION DEL SEGMENTO DE PILA

PILA SEGMENT STACK "STACK"
DB 40H DUP (0)
PILA ENDS
;_______________________________________________________________________
;_______________________________________________________________________

; DEFINICION DEL SEGMENTO EXTRA

EXTRA     SEGMENT
                RESULT    DW 0,0                ; 2 PALABRAS ( 4 BYTES )
EXTRA ENDS
;_______________________________________________________________________
;_______________________________________________________________________
;                             DEFINICION DEL SEGMENTO DE CODIGO

CODE SEGMENT
ASSUME CS:CODE, DS:DATOS, ES: EXTRA, SS:PILA

FACT_DATO_1 DW 0

; COMIENZO DEL PROCEDIMIENTO PRINCIPAL

START PROC
         ;INICIALIZALOS REGISTROS DE SEGMENTO CON SUS VALORES
         MOV AX, DATOS
         MOV DS, AX

MOV AX, PILA
MOV SS, AX

MOV AX, EXTRA
MOV ES, AX

; CARGA EL PUNTERODE PILA CON EL VALOR MAS ALTO
MOVSP, 64

; FIN DE LAS INICIALIZACIONES

;COMIENZO DELPROGRAMA

        MOV CL, DATO_1
        CALL FACTOR
        MOV FACT_DATO_1,AX       ; ALMACENA EL RESULTADO
        MOV CL, DATO_2
        CALL FACTOR
        MOV BX, FACT_DATO_1
        MUL BX                    ; EN AX ESTA EL RESULTADO DEL FACTORIAL DEL SEGUNDO

       ; ALMACENA EL RESULTADO
       MOV RESULT, AX
       MOV RESULT+2, DX

       ; FIN DEL PROGRAMA
        MOV AX, 4C00H
        INT 21H

START ENDP
;_______________________________________________________________
; SUBRUTINA PARA CALCULAR EL FACTORIAL DE UN NUMERO
; ENTRADA CL=NUMERO
; SALIDA AX=RESULTADO, DX=0 YA QUE CL<=9
;_______________________________________________________________

FACTOR PROC NEAR
       MOV AX, 1
       XOR CH,CH
       CMP CX, 0
       JE FIN
IR:
       MUL CX
       DEC CX
       JNE IR
FIN:
       RET
FACTOR ENDP

; FIN DEL SEGMENTO DE CODIGO
CODE ENDS
; FIN DEL PROGRAMA INDICANDO DONDE COMIENZA LA EJECUCION
END START
;_______________________________________________________________________

En el programa fuente anterior es importante destacar:

El orden en que aparecen los diferentes segmentos (datos, código,pila) dentro del programa fuente es indiferente. Alguno puede no aparecer.El segmento de pila debe aparecer si se utilizan instrucciones que la usan,si se utilizan recursos del sistema o si se piensa hacer "debug".En general, todos los programas necesitan una pila con un tamañomínimo de 64 bytes.
Al definir el comienzo del segmento de pila hay que escribir: SEGMENT STACK"STACK"
Al comienzo del segmento de código hay que utilizar la directivaASSUME para relacionar el nombre dado a los segmentos con el registro desegmento a través del cual van a ser accedidas las posiciones dememoria existentes en cada segmento. Sin embargo esta directiva no cargael valor de los registros de segmento (DS, SS, ES) con los valores asignadosa los segmentos. Las instrucciones que cargan estos valores deben ser lasprimeras de cualquier programa.
Las instrucciones sólo pueden existir en el segmento de código.Sin embargo, los datos pueden estar en cualquier segmento. La situaciónmás usual es que aparezcan todos en el segmento de datos.
Para finalizar el programa es necesario utilizar la interrupciónINT 21H con AX=4C00h, que devuelve el control al DOS.
La última línea debe tener la directiva END seguida por elnombre del procedimiento donde empieza a ejecutarse el programa.

Para poder ensamblar el programa hay que tener el path dirigidoa c:\tasm;c:\td y escribir d:\> TASM /zi factordonde factor es el nombre del programa fuente a ensamblar. La terminación.ASM es innecesaria. El ensamblador crea dos ficheros a partir de factor.asmque son factor.obj (código máquina traducido) y factor.lst(listado del programa). El fichero .obj se crea sólo si no ha habidoerrores de compilación. Para que se genere el fichero de listadoes necesario escribir: d:\> TASM /zi factor,,factordonde la segunda aparición de la palabra factor es el nombredel fichero listado. La opción /zi sólo es necesaria si sequiere producir código adicional para poder hacer "debug"del programa.

El fichero factor.obj necesita ser "linkado" (encadenado) parapoder ejecutarse. Para hacer el link hay que escribir

d:\> TLINK /v factorEl fichero generado es factor.exe y es un fichero ejecutable a falta dela asignación de valores a los diferentes segmentos del programa.Si este programa se ejecuta desde el PC, el sistema operativo DOS se encargade asignar valores a los diferentes segmentos. Para observar esto se utilizaráel programa de debug TD, que permite controlar la ejecuciónde programas en código máquina en el PC. Para ello se escribe:d:\> TD FACTOREjemplo de uso del TD.

Entrar en el menú de VIEW y activar la ventana de CPU. Dichaventana está compuesta por otras subventanas

instrucciones
datos
registros
registro de estado o flags
pilaPara pasar de una ventana a otra presionar TAB. Cada zona tiene un menúlocal al que se accede con ALT-F10. Presionando esta combinaciónde teclas desde la zona de instrucciones y poniendo en MIXED Yes, se tendráun listado del programa fuente y el programa ensamblado. En general, desdecada menú local se pueden cambiar las distintas zonas de la memoriaque se visualiza en cada ventana o bien cambiar los valores de los registros.

Para ejecutar un programa, acceder al menú RUN en el que se tienendiferentes opciones:

Trace: ejecuta las instrucciones paso a paso
Run: ejecuta hasta el final del programa
Step: ejecuta hasta la instrucción localizada a continuación
Cursor: ejecuta hasta la instrucción marcada con el cursorEs cada instante, la instrucción siguiente a ejecutar estámarcada con una flecha.

Análisisde un programa en ensamblador

Primer ejemplo: sencillo

Segundo ejemplo: código más completo, varios ficheros fuente, interacción con C.