Sobre cómo dividir un programa ensamblador x86 (modo Real) en módulos compilables por separado.

Transcripción

1 Sobre cómo dividir un programa ensamblador x86 (modo Real) en módulos compilables por separado. Fuente de la información de partida para este documento: PRIMERO El objetivo de este documento es describir de una forma práctica cómo dividir un programa ensamblador en archivos separados que pueden ser ensamblados por separado y luego deben ser linkados para formen una unidad ejecutable. Está descrito desde la ignorancia teórica de muchos aspectos y la experiencia práctica de unos pocos. Parto de que quiero escribir un programa ensamblador relativamente largo, por lo que me gustaría poder trabajar con varios archivos separados, de manera que en un archivo tenga el programa principal y en otros archivos las diversas rutinas que se invocan desde éste. Podría, por ejemplo, separar las rutinas dedicadas a los asuntos de pantalla en un archivo, las rutinas dedicadas a los asuntos de procesamiento de datos en otro, etc. En mi ejemplo, me he creado un archivo principal, main.asm que se limita a llamar a una rutina que imprime un texto en pantalla. Pero esta rutina print, no está en el actual archivo sino en otro llamado module.asm. He complicado un poco la cosa haciendo que en la invocación a print en main, el texto que se imprima sea la mitad de una frase. La siguiente instrucción después de la invocación es un salto a una etiqueta resto que también está en module. Con esto pretendo conseguir que el flujo del programa comience ejecutándose en este archivo main luego salte a ejecutar código que está en el archivo module y por último regrese a main para terminar. El código que se escribió en module a partir de la etiqueta resto vuelve a invocar a la rutina print y se espera que ahora se imprima el resto de la frase. En primer lugar, las etiquetas print y resto no están en el archivo main.asm, por lo que el ensamblador las va a echar de menos. Es por eso que utilizamos la directiva. Con esta directiva le indicamos al ensamblador que esas etiquetas están definidas en otro archivo, de manera que el ensamblador esperará a el lincado para resolverlas. Obsérvese cómo hemos declarado ambas etiquetas detrás de la directiva, y que tras cada etiqueta, separado por dos puntos hay un indicador: far. Estos indicadores son obligatorios y nos indican que ambas etiquetas están en otro segmento, por lo que preparamos al ensamblador para que al construir la dirección de salto se haga con una dirección de segmento y un desplazamiento (en el caso de que la declaración fuera near, el no haría falta más que el desplazamiento puesto que se asume que el segmento es el mismo del proceso actual, ya en CS).

2 A continuación defino el segmento de datos y el de código de la manera corriente para realice lo que se pretende, no hay mucho que destacar salvo que he sacado fuera de print la inicialización de DX (la dirección del texto que deseo imprimir). Debo recordar que print invoca a la función 9h de la INT 21h, que imprime un texto en pantalla y que esta rutina asume que la dirección del texto a imprimir viene indicada en DS:DX por lo que en el programa se inicializa el registro DS para que apunte al segmento de datos de este módulo y DX para que apunte al comienzo del texto a imprimir (recordar que el final del texto a imprimir es el $ ). Como se puede verificar, al ejecutar este código se invocará a print escribirá en pantalla el texto Esta es la reina y luego salta a la etiqueta resto que está en el archivo module.asm; a él vamos ahora. En este archivo hemos vuelto a definir un segmento de datos y un segmento de códigos. Aunque tienen los mismos nombres que en archivo main.asm el ensamblador va a saber distinguirlos como cosas distintas porque mantiene listas separadas de símbolos. No va a ocurrir lo mismo con los símbolos definidos como y. Como se ve, en este archivo hemos definido como la etiqueta exit. Ello es porque dentro del código escrito en este archivo saltamos a esta etiqueta que está en el archivo main.asm. De nuevo estamos diciéndole al ensamblador que no se preocupe si no encuentra esta etiqueta dentro de este archivo, que seguro que está definida en otro lado, como en efecto así nos hemos asegurado definiendo como esta etiqueta en main.asm. Por otro lado, para corresponder a la declaración de print y resto como en main.asm, declaramos aquí esas etiquetas como. Otro detalle que es relevante es la necesidad de declarar el procedimiento print como far y de no olvidar terminar con un retf. Es importante esta declaración para que la llamada al procedimiento y su retorno se haga correctamente, escribiendo en la pila tanto el segmento como el desplazamiento de la dirección de retorno cuando se haga la invocación y recuperando de la pila ambos elementos cuando se produzca el retorno. Observamos el detalle de que, de nuevo, antes de invocar a print en module.asm, debemos redefinir el contenido de DS para que cuando invoquemos a la rutina de impresión en pantalla el texto que imprima sea el que está declarado en el segmento de datos de este módulo que, como hemos dicho, es distinto del segmento de datos declarado en main.asm aunque tengan el mismo nombre. Y listo, cuando la ejecución del programa comenzado en main.asm salte a la etiqueta resto, reinicializará DS y DX, invocará a print para que escriba de Africa\n y luego saltará a la etiqueta exit, volviendo a main.asm, en donde terminará la ejecución invocando a la función 4Ch de la INT 21h. DETALLES Cada archivo se ensambla por separado: Tasm main.asm Tasm module.asm Luego se enlazan juntos

3 Tlink main.obj module.obj En principio el orden no debería importar. Solo uno de los módulos debe terminar con una etiqueta de comienzo de ejecución, en nuestro caso está en main, que termina: END start SEGUNDO En el ejemplo de arriba hemos creado dos archivos en los que hemos definido un segmento de datos y un segmento de código separados. Por ello hemos utilizado las definiciones de FAR. El programa que se cree va a constar realmente de 4 segmentos, dos de código y dos de datos, uno de cada por cada uno de los archivos que hemos creado. (la creación del segmento de pila dejamos que se cree por defecto). En este segundo ejemplo vamos a crear dos archivos con secciones de código separadas, pero cuando vayan a ser montados se considerarán un único segmento de código, un único segmento de datos y un único segmento de pila. Los archivos son externo.asm, que contendrá el comienzo de la ejecución y public.asm, que contendrá la parte secundaria. En primer lugar destacar que en externo.asm hemos definido como la etiqueta exit y como las etiquetas print y resto, pero esta vez ambas están definidas como near. También destacar que ahora las definiciones de segmentos también están marcadas, por ejemplo, el segmento stake que va a ser el de pila es marcado como Word stack STACK, el segmento que será el de datos indica Word public DATA y el segmento que será el de código dice byte puclic CODE. Si observamos ahora el archivo public.asm veremos, aparte de la correspondencia con externo.asm en las definiciones de y la misma correspondencia en la definición de los segmentos. Desde el desconocimiento, tan sólo la intuición, aventuro a explicar que Word public DATA y Word public CODE es la manera en que se está diciendo que ambos segmentos de datos van a formar parte del mismo segmento de datos en el programa final, es decir, que van a conformar un único segmento. Es por ello que no es necesario, por ejemplo, describir la rutina print como far. DETALLES Cada archivo se ensambla por separado: Tasm externo.asm Tasm public.asm Luego se enlazan juntos. Tlink externo.obj public.obj En principio el orden no es relevante, asegurándose que uno solo de los módulos contiene al final la etiqueta de comienzo de ejecución, en este caso externo.asm

4 END start

5 ANEXO Reina main exit print:far, resto:far db "Esta es la reina",'$' ASSUME cs:, ds: start: mov ax, mov ds,ax ; carga localizacion del segmento ; en el registro DS mov dx, offset Reina jmp resto ; va a PRINT en el otro modulo exit: mov ah,4ch int 21h END start module print, resto exit:far demas DB " de Africa",13,10,"$" ASSUME cs:, ds: print proc far

6 mov ah, 09h int 21h retf endp resto: mov ax, mov ds, ax mov dx, OFFSET demas jmp exit ; Regresa al otro modulo END stacke externo exit print:near, resto:near word stack 'STACK' DW 64 DUP(?) stacke word public 'DATA' entrada DB "Entrando a un submodulo...",13,10,"$" byte public 'CODE' ASSUME cs:, ds: start: mov ax, mov ds,ax ; carga localizacion del segmento ; en el registro DS mov dx, offset entrada jmp resto ; va a PRINT en el otro modulo

7 exit: mov ah,4ch int 21h END start public print, resto exit:near word public 'DATA' salida DB "...saliendo del submodulo.",13,10,"$" byte public 'CODE' ASSUME cs:, ds: print proc mov ah, 09h int 21h ret endp resto: mov dx, OFFSET salida jmp exit ; Regresa al otro modulo END