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

; Ejemplo de macro de una sola línea

; 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

; Ruta del archivo: macro_multi.asm
; 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

; Ejemplo de parámetros avanzados de macros

; 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

; Etiquetas locales en macros

; 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ísticaMacroProcedimiento
Método de implementaciónExpansión de texto en tiempo de compilaciónCALL/RET en tiempo de ejecución
Sobrecarga de ejecuciónSin sobrecarga de llamada (en línea directa)Con sobrecarga de CALL/RET (aproximadamente unos ciclos de reloj)
Tamaño del códigoAumenta el tamaño en cada expansiónUn solo código llamado múltiples veces
Tipo de parámetrosCualquier texto (registros, inmediatos, memoria)Valores en tiempo de ejecución
DepuraciónDifícil (sin rastro después de la expansión)Fácil (hay pila de llamadas de funciones)
Escenarios aplicablesCódigo corto, llamado con frecuencia y con tipos flexiblesFunciones 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

; Ruta del archivo: cond_compile.asm
; 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:

EscenarioEjemplo
Cambio depuración/release%if DEBUG / %else / %endif
Adaptación de plataforma%ifdef LINUX / %ifdef WINDOWS
Interruptor de funcionesControlar 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

; Ejemplo de bloque de repetición %rep

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

El 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.

Otras extensiones