Macros en ensamblador

Hola a casi todos, quiero compartir con ustedes una pequeñita información acerca del uso de Macros en ensamblador ... ojalá que sea de utilidad

Macros

Al programar en lenguaje ensamblador encontramos en muchas ocasiones que parte del código se repite. Existen diferentes alternativas para no escribir ese código cada vez que lo necesitemos.

• Usar procedimientos e invocarlos cuando sean necesarios. La desventaja de usarlos es que se podría hacer el programa medio lento.
• Usar macros.

Partes de una macros

La definición de una macros es una forma de asignarle nombre a un fragmento de texto. En general las macros se componen de las siguientes partes:

1. Cabecera de macro: Da el nombre de la macro que se está definiendo.

2. Cuerpo de la macro: Las acciones a realizar.

3. Una pseudoinstrucción: Marca el final de la definición (%endmacro).

%macro imprime 2 CABECERA DE MACRO
mov dx,%1 mov cx,%2

Definición de mov bx,1 CUERPO DE LA MACRO

macro mov ax,4 int 80h

%endmacro FIN DE LA MACRO

Cada vez que el ensamblador encuentra en su código una definición de macro la guarda en la tabla de definición de macros. Así, cada vez que el nombre de la macro aparezca en el código de operación el ensamblador la busca en la tabla de definición de macros y sustituye el nombre por el cuerpo de la macro.

Usar el nombre de la macro como código se denomina llamada a macro y la sustitución de éste por el cuerpo de la macro se llama expansión de macro, la cual se efectúa durante el ensamblado y no en la ejecución del programa. Cuando finaliza la expansión de la macro el ensamblador desecha las definiciones de macros.

Una llamada a una macro es una instrucción al ensamblador para sustituir el nombre de la macro por el cuerpo de la misma, por lo tanto, no se provoca un salto en el registro IP; mientras que una llamada a un procedimiento es una instrucción de máquina que se inserta en el programa objeto y que posteriormente se ejecutará para llamar al procedimiento, guardando la “posición actual”, haciendo un salto en el registro IP, y posteriormente retomando la posición donde fue llamada.

Ya habíamos estudiado anteriormente que existen ensambladores de dos pasadas. En la primer pasada, las definiciones de macros se guardan y las llamadas a macros se expanden. En la segunda pasada el programa fuente se ha transformado en otro que eliminó las definiciones de macros.

En ocasiones las secuencias de instrucciones sólo varían en las variables a las cuales son aplicadas; entonces, podemos definir macros con parámetros formales que al ser expandidas sustituyan éstos parámetros formales por los parámetros reales correspondientes.

En este sentido, podemos definir a las macros en dos grupos:

• Macro de una sola línea: Se definen mediante la palabra reservada define su sintaxis es:

%define nombre ( parámetros_formales ) código

%define incrementa ( x, y ) add x,y

• Macros multilínea: Son macros que contienen mas de una línea en el código del cuerpo de la macro, para englobar el conjunto de instrucciones que pertenecen a la macro usamos las instrucciones %macro y %endmacro:

%macro nombre num_de_parametros

<>

%endmacro

%macro hacer_algo 2

mov ax, %1

mov bx, %2

%endmacro

Para utilizar una macro solo es necesario llamarla por su nombre, como si fuera una instrucción más del ensamblador, ya no son necesarias las directivas como en el caso de los procedimientos.

En el curso de Arquitectura de Computadoras II, estudiamos el uso de etiquetas en lenguaje ensamblador. Una de las “reglas” fue que no podía haber más de una etiqueta con el mismo nombre a lo largo del programa.

¿Qué sucede entonces cuando al definir macros necesitamos emplear etiquetas? La respuesta es: declarar etiquetas localmente, la manera de declararlas es anteponiendo al nombre de la etiqueta el símbolo %%.

%macro nombre_macro num_parámetros %macro repite 0

Línea 1; mov cx,10

Línea 2; mov dx,1

… %%ciclo:

%%nombre_etiqueta: inc dx

<> loop %%ciclo

… %endmacro

MasLíneas

%endmacro

Si hacemos uso de un grupo de macros, podemos guardarlas en un archivo con extensión .inc (mismacros.inc). Para que alguna de estas macros pueda ser usada en un programa se debe incluir la palabra reservada %include seguida del nombre del archivo que contiene las macros entre comillas

%include “mismacros.inc”

Cada vez que el ensamblador llega a una definición de macro, se crea una entrada en la tabla de macros con el nombre de ésta, el número de parámetros formales y un apuntador a otra tabla en la cual se encuentra almacenado el cuerpo de la macro. También se construye una lista de parámetros formales que se usarán al procesar la definición. Luego se lee el cuerpo de la macro y se guarda en la tabla de definiciones de macros. Los parámetros formales que ocurren dentro del cuerpo se indican con algún símbolo especial.

Durante la primer pasada del ensamblador las macros se expanden, cada vez que se encuentra una definición de macro se guarda en la tabla de macros. Cuando se invoca una macro, el ensamblador suspende temporalmente la lectura del dispositivo de entrada y comienza a leer el cuerpo almacenado de la macro, los parámetros formales se extraen del cuerpo almacenado de la macro y se sustituyen por los parámetros reales proporcionados en la llamada. La presencia del % antes de los parámetros formales permite al ensamblador reconocerlos fácilmente.