Lenguaje ensamblador - Macros
Una macro (Macro) es un mecanismo de reutilización de código proporcionado por NASM que permite expandir plantillas de código en tiempo de compilación, reduciendo la necesidad de escribir repetidamente código similar.
Qué es una macro
MacroEs un mecanismo de reemplazo de texto en tiempo de compilación, expandido por el preprocesador del ensamblador antes de compilar.
A diferencia de los procedimientos, las macros no tienen sobrecarga de CALL/RET: cada vez que se usa una macro, el compilador copia el contenido de la macro directamente en el lugar de uso.
Una macro no es una llamada a función, no tiene sobrecarga de marco de pila; pero el archivo ejecutable será más grande, porque cada expansión copia una copia del código.
Macro de una sola línea: %define
%defineEs una macro de una sola línea, con sintaxis simple:
Ejemplo
; Definir una constante
%define MAX_SIZE 256
%define APP_NAME 'ejemplo'
; Definir una macro con parámetros (función macro)
%define mul_by_2(x) (x * 2)
%define sum3(a, b, c) ((a) + (b) + (c))
section .text
global _start
_start:
mov eax, MAX_SIZE ; eax = 256
mov eax, mul_by_2(10) ; eax = (10 * 2) = 20
mov eax, sum3(1, 2, 3) ; eax = ((1)+(2)+(3)) = 6
; Redefinir (%define puede cambiar)
%define MAX_SIZE 512
mov eax, MAX_SIZE ; eax = 512
; Anular definición
%undef MAX_SIZE
; mov eax, MAX_SIZE ; Error: MAX_SIZE no está definido
mov eax, 1
mov ebx, 0
int 0x80
%defineLa expansión de macros es un reemplazo de texto puro. Por ejemplomul_by_2(2+3)se expande a(2+3 * 2), debido a la precedencia de operadores, el resultado no es 10 sino 8. Esta es la razón por la que los parámetros de macros deben ir entre paréntesis.
Macro multilínea: %macro / %endmacro
%macroSe utiliza para definir macros complejas que contienen múltiples instrucciones:
Ejemplo
; Ejemplo de macro multilínea
; Definición de macro: salir del programa
; Parámetro argc: cuántos parámetros acepta la macro
%macro exit_program 1
mov eax, 1 ; sys_exit
mov ebx, %1 ; El primer parámetro como código de salida
int 0x80
%endmacro
; Definición de macro: imprimir cadena
; Acepta 2 parámetros: dirección de la cadena, longitud
%macro print_string 2
push eax
push ebx
push ecx
push edx
mov eax, 4 ; sys_write
mov ebx, 1 ; stdout
mov ecx, %1 ; Dirección de la cadena
mov edx, %2 ; Longitud de la cadena
int 0x80
pop edx
pop ecx
pop ebx
pop eax
%endmacro
section .data
msg db 'Hello, EJEMPLO!', 0xA
msg_len equ $ - msg
section .text
global _start
_start:
print_string msg, msg_len ; Usar la macro para imprimir un mensaje
print_string msg, msg_len ; Llamar de nuevo
exit_program 0 ; Salir del programa
Uso avanzado de parámetros de macros
Las macros de NASM admiten parámetros predeterminados, recuento de parámetros y expansión condicional:
Ejemplo
; Macro con parámetros predeterminados (rango de parámetros 2-3)
%macro debug_print 2-3 1 ; Al menos 2 parámetros, como máximo 3, el tercero por defecto = 1
%if %3 = 1 ; Si el tercer parámetro = 1 (modo depuración activado)
push eax
push ebx
push ecx
push edx
mov eax, 4
mov ebx, 1
mov ecx, %1
mov edx, %2
int 0x80
pop edx
pop ecx
pop ebx
pop eax
%endif
%endmacro
; Macro con número variable de parámetros
%macro push_registers 1-* ; De 1 a cualquier número de parámetros
%rep %0 ; %0 es el número de parámetros
push %1 ; Expandir el primero
%rotate 1 ; Rotar la lista de parámetros a la izquierda
%endrep
%endmacro
section .text
global _start
_start:
; Usar push_registers para guardar múltiples registros
push_registers eax, ebx, ecx, edx
; Se expande a:
; push eax
; push ebx
; push ecx
; push edx
; Realizar el pop correspondiente
pop edx
pop ecx
pop ebx
pop eax
mov eax, 1
mov ebx, 0
int 0x80
Etiquetas locales en macros
En macros se usa%%labeldefinir etiquetas locales, para evitar conflictos de etiquetas al expandir varias veces:
Ejemplo
; Comparar dos valores y establecer el mínimo
%macro min_val 2
mov eax, %1
mov ebx, %2
cmp eax, ebx
jle %%skip ; ★ Etiqueta local, cada expansión genera un nombre único
mov eax, ebx
%%skip:
%endmacro
; Si no se usan etiquetas locales, después de expandir dos veces aparecerán etiquetas skip duplicadas
section .text
global _start
_start:
min_val 10, 5 ; eax = 5
min_val eax, 3 ; eax = 3
mov eax, 1
mov ebx, 0
int 0x80
Las etiquetas normales expandidas dos veces en una macro provocan errores de etiquetas duplicadas. Las etiquetas locales
%%labelhacen que NASM genere un nombre de etiqueta único en cada expansión (como..@0001.skip), evitando conflictos.
Comparación entre macros y procedimientos
| Característica | Macro | Procedimiento |
|---|---|---|
| Método de implementación | Expansión de texto en tiempo de compilación | CALL/RET en tiempo de ejecución |
| Sobrecarga de ejecución | Sin sobrecarga de llamada (en línea directa) | Con sobrecarga de CALL/RET (aproximadamente unos ciclos de reloj) |
| Tamaño del código | Aumenta el tamaño en cada expansión | Un solo código llamado múltiples veces |
| Tipo de parámetros | Cualquier texto (registros, inmediatos, memoria) | Valores en tiempo de ejecución |
| Depuración | Difícil (sin rastro después de la expansión) | Fácil (hay pila de llamadas de funciones) |
| Escenarios aplicables | Código corto, llamado con frecuencia y con tipos flexibles | Funciones con lógica compleja y gran cantidad de código |
Compilación condicional: %if / %elif / %else / %endif
El preprocesador de macros admite compilación condicional, pudiendo elegir generar diferentes códigos según la definición de símbolos:
Ejemplo
; Ejemplo de compilación condicional: modos de depuración y release
%define DEBUG 1 ; 1=modo depuración, 0=modo release
section .data
msg db 'Program running...', 0xA
msg_len equ $ - msg
debug_msg db '[DEBUG] Entering function', 0xA
debug_len equ $ - debug_msg
section .text
global _start
_start:
%if DEBUG = 1
; Modo depuración: mostrar información de depuración
mov eax, 4
mov ebx, 1
mov ecx, debug_msg
mov edx, debug_len
int 0x80
%endif
; Lógica de negocio normal
mov eax, 4
mov ebx, 1
mov ecx, msg
mov edx, msg_len
int 0x80
mov eax, 1
mov ebx, 0
int 0x80
Escenarios comunes de compilación condicional:
| Escenario | Ejemplo |
|---|---|
| Cambio depuración/release | %if DEBUG / %else / %endif |
| Adaptación de plataforma | %ifdef LINUX / %ifdef WINDOWS |
| Interruptor de funciones | Controlar características según la existencia o no de símbolos |
Bloques de repetición %rep
%repSe utilizan para generar código o datos repetidos:
Ejemplo
section .data
; Generar una tabla de búsqueda de 256 bytes
; 0, 1, 4, 9, 16, 25, ... (tabla de cuadrados)
%assign i 0
; Aquí no se puede usar %rep para generar la tabla de cuadrados haciendo cálculos complejos
; Ejemplo simple: generar la tabla ASCII del 0-9
digits: db '0', '1', '2', '3', '4', '5', '6', '7', '8', '9'
section .text
global _start
_start:
; %rep repite instrucciones en el código
mov eax, 0
%rep 5 ; Repetir 5 veces
inc eax ; eax se incrementa en 1 cada vez
%endrep
; eax = 5
mov ebx, eax
mov eax, 1
int 0x80
Otras extensionesEl uso excesivo de macros dificulta la lectura y depuración del código. Cuando el cuerpo de la macro supere las 10 líneas, considere cambiarlo a una llamada a procedimiento. En rutas calientes sensibles al rendimiento, la inserción en línea de macros cortas aporta beneficios evidentes.