Práctica 0. Introducción

Metodología de diseño

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

Programación en ensamblador: entorno Turbo Assembler y Turbo Debugger

Análisis de un programa en ensamblador

Ejercicios propuestos

Metodología de diseño

Programación modular

A la hora de desarrollar un programa pequeño, cualquier metodología puede valer. El problema surge cuando ese programa va creciendo, con lo que la cantidad de sentencias lo hace poco legible y ya no es posible hacer un seguimiento lógico de su ejecución. Otro factor a tener en 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 sean diferentes programadores los que intervengan en el desarrollo de una aplicación.

Parece claro que la solución pasa por la formulación de programas complejos a partir de secuencias pequeñas, o módulos, cada uno de los cuales realiza una tarea bien definida. Es lo que se denomina una 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 tienen que comunicarse entre sí.
Escritura de las tareas en lenguaje ensamblador y conexión de los mó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ódulos es el diagrama jerárquico, que es una figura orientada a bloques que resume las relaciones entre los módulos (tareas) y submódulos (subtareas). El diagrama jerárquico muestra la cadena de subordinaciones que existen entre los módulos y submódulos. Es una gran ayuda tanto para el programador como para cualquier otra persona que quiera analizar el programa, ya que permite ver de forma clara su estructura funcional.

Las razones para dividir un programa en partes más pequeñas pueden 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 una forma 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ódulos que se almacenan en librerías para ser utilizados por varios programas.

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

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

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

Proceso de ensamblaje

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

Entrada y salida del ensamblador

Enlace y reubicación

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

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

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

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

Programación en ensamblador: entorno Turbo Assembler y Turbo Debugger

Para realizar un programa que se ejecute en un PC, hay que partir de un fichero fuente en ensamblador, escrito con un editor de texto, que genere có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 QUE SE
; ENCUENTRAN EN LAS POSICIONES DE MEMORIA 0 Y 1 DEL SEGMENTO DE
; DATOS. EL VALOR DE CADA NUMERO DEBE SER INFERIOR A 9. EL RESULTADO
; SE ALMACENA EN DOS PALABRAS DEL SEGMENTO EXTRA, EN LA PRIMERA
; PALABRA EL MENOS SIGNIFICATIVO Y EN LA SEGUNDA EL MAS
; SIGNIFICATIVO. SE UTILIZA UNA RUTINA PARA CALCULAR EL 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
         ;INICIALIZA LOS 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 PUNTERO DE PILA CON EL VALOR MAS ALTO
MOV SP, 64

; FIN DE LAS INICIALIZACIONES

;COMIENZO DEL PROGRAMA

        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ño mí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 directiva ASSUME para relacionar el nombre dado a los segmentos con el registro de segmento a través del cual van a ser accedidas las posiciones de memoria existentes en cada segmento. Sin embargo esta directiva no carga el valor de los registros de segmento (DS, SS, ES) con los valores asignados a los segmentos. Las instrucciones que cargan estos valores deben ser las primeras 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ón más usual es que aparezcan todos en el segmento de datos.
Para finalizar el programa es necesario utilizar la interrupción INT 21H con AX=4C00h, que devuelve el control al DOS.
La última línea debe tener la directiva END seguida por el nombre del procedimiento donde empieza a ejecutarse el programa.

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

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

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

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

instrucciones
datos
registros
registro de estado o flags
pila Para pasar de una ventana a otra presionar TAB. Cada zona tiene un menú local al que se accede con ALT-F10. Presionando esta combinación de teclas desde la zona de instrucciones y poniendo en MIXED Yes, se tendrá un listado del programa fuente y el programa ensamblado. En general, desde cada menú local se pueden cambiar las distintas zonas de la memoria que 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 tienen diferentes 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 cursor Es cada instante, la instrucción siguiente a ejecutar está marcada con una flecha.

Análisis de un programa en ensamblador

Programa ALUMNO.ASM

;_______________________________________________________________
; DEFINICION DEL SEGMENTO DE DATOS

DATOS SEGMENT

CLR_PANT       DB 1BH,"[2","J$"
CUR_MICRO    DB 1BH,"4;27fTECNOLOGIA DE COMPUTADORES$"
PREG_NOM      DB 1BH,"[15;1fESCRIBE TU NOMBRE ? $"
NOMBRE          DB 80 DUP (0)
TEXTO              DB 1BH,"[22;1fDON","$"
TEXTO2            DB " ES ALUMNO DE 2º CURSO DE "
                           DB "INGENIERIA INFORMATICA",13,10,"$"

DATOS ENDS
;_______________________________________________________________
; DEFINICION DEL SEGMENTO DE PILA

PILA                  SEGMENT STACK "STACK"
                           DB 40H DUP (0)
PILA                  ENDS
;_______________________________________________________________
; DEFINICION DEL SEGMENTO DE CODIGO

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

; COMIENZO DEL PROCEDIMIENTO PRINCIPAL (START)
START             PROC FAR
                        ;INICIALIZACION DE LOS REGISTROS DE SEGMENTO
                        MOV AX,DATOS
                        MOV DS,AX

;FIN DE LAS INICIALIZACIONES

                       ; BORRA LA PANTALLA
                       MOV AH,9
                       MOV DX, OFFSET CLR_PANT
                       INT 21H

                       ;ESCRIBE "CURSO ...
                       MOV DX,OFFSET CUR_MICRO
                       INT 21H

                      ;MUESTRA "ESCRIBE ...
                       MOV DX,OFFSET PREG_NOM
                       INT 21H

                      ;ALMACENA EL NOMBRE TECLEADO
                       MOV AH,0AH
                       MOV DX,OFFSET NOMBRE
                       MOV NOMBRE[0],60                       ;MAXIMO NUMERO DE CARACTERES
                       INT 21H

                      MOV AH,9
                      MOV DX, OFFSET TEXTO               ;ESCRIBE "DON ...
                      INT 21H

MOV BX,0

OTRO:
                      MOV DL,NOMBRE[BX+2]
                      MOV AH,2
                      INT 21H                                              ;ESCRIBIR UN CARACTER DEL NOMBRE
                      INC BX
                      CMP BL, NOMBRE[1]                       ;COMPARA CON EL NUMERO DE CARACTERES
                      JNE OTRO

                      ; ESCRIBE "ES ALUMNO ...
                     MOV DX, OFFSET TEXTO2
                     MOV AH,9
                     INT 21H

; FIN DE PROGRAMA Y VUELTA AL DOS
MOV AX,4C00H
INT 21H

START ENDP

;FIN DEL SEGMENTO DE CODIGO
CODE ENDS

;FIN DE PROGRAMA INDICANDO DONDE COMIENZA LA EJECUCION
END START

Compilar y enlazar (linkar) el programa ALUMNO.ASM. Ejecutarlo dede el programa TD. Ejecutarlo directamente desde el DOS. Modificar el programa para que pregunte separadamente por el nombre, primer apellido y segundo apellido. Comprobar el funcionamiento.