Langage d'assemblage - Macros

Une macro est un mécanisme de réutilisation de code fourni par NASM qui permet d'étendre des modèles de code au moment de la compilation, réduisant ainsi le besoin d'écrire répétitivement du code similaire.


Qu'est-ce qu'une macro

MacroC'est un mécanisme de remplacement de texte au moment de la compilation qui est étendu par le préprocesseur de l'assembleur avant la compilation.

Contrairement aux procédures, les macros n'ont pas de surcoût CALL/RET — chaque fois qu'une macro est utilisée, l'assembleur copie directement le contenu de la macro à l'endroit d'utilisation.

Une macro n'est pas un appel de fonction et n'a pas de surcoût de trame de pile ; cependant, la taille du fichier exécutable augmente parce qu'une copie du code est effectuée à chaque expansion.


Macro monoligne : %define

%defineC'est une macro monoligne avec une syntaxe simple :

Exemple

; Exemple de macro monoligne

; Définir une constante
%define MAX_SIZE 256
%define APP_NAME 'example'

; Définir une macro avec paramètres (fonction 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

    ; Redéfinition (%define peut être modifié)
    %define MAX_SIZE 512
    mov eax, MAX_SIZE            ; eax = 512

    ; Annuler la définition
    %undef MAX_SIZE
    ; mov eax, MAX_SIZE ; Erreur : MAX_SIZE n'est pas défini

    mov eax, 1
    mov ebx, 0
    int 0x80

%defineL'expansion de macro est un pur remplacement de texte. Par exemple,mul_by_2(2+3)se développe en(2+3 * 2), en raison de la priorité des opérateurs, le résultat n'est pas 10 mais 8. C'est pourquoi les paramètres de macro doivent être mis entre parenthèses.


Macro multiligne : %macro / %endmacro

%macroUtilisé pour définir des macros complexes contenant plusieurs instructions :

Exemple

; Chemin du fichier : macro_multi.asm
; Exemple de macro multiligne

; Définition de macro : sortie du programme
; Paramètre argc : combien de paramètres la macro accepte
%macro exit_program 1
    mov eax, 1                   ; sys_exit
    mov ebx, %1                  ; Le premier paramètre est utilisé comme code de sortie
    int 0x80
%endmacro

; Définition de macro : afficher une chaîne
; Accepte 2 paramètres : adresse de chaîne, longueur
%macro print_string 2
    push eax
    push ebx
    push ecx
    push edx
    mov eax, 4                   ; sys_write
    mov ebx, 1                   ; stdout
    mov ecx, %1                  ; Adresse de la chaîne
    mov edx, %2                  ; Longueur de la chaîne
    int 0x80
    pop edx
    pop ecx
    pop ebx
    pop eax
%endmacro

section .data
    msg db 'Hello, EXAMPLE!', 0xA
    msg_len equ $ - msg

section .text
    global _start

_start:
    print_string msg, msg_len     ; Utiliser la macro pour afficher un message
    print_string msg, msg_len     ; Appeler à nouveau
    exit_program 0                ; Quitter le programme

Utilisation avancée des paramètres de macro

Les macros NASM prennent en charge les paramètres par défaut, le comptage des paramètres et l'expansion conditionnelle :

Exemple

; Exemple de paramètres avancés de macro

; Macro avec paramètres par défaut (plage de paramètres 2-3)
%macro debug_print 2-3 1        ; Au moins 2 paramètres, au plus 3, le 3e vaut 1 par défaut
    %if %3 = 1                   ; Si le 3e paramètre = 1 (mode débogage activé)
        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 avec un nombre variable de paramètres
%macro push_registers 1-*        ; 1 à un nombre quelconque de paramètres
    %rep %0                      ; %0 est le nombre de paramètres
        push %1                  ; Développe le 1er
        %rotate 1                ; Fait tourner la liste des paramètres vers la gauche
    %endrep
%endmacro

section .text
    global _start

_start:
    ; Utilisez push_registers pour sauvegarder plusieurs registres
    push_registers eax, ebx, ecx, edx
    ; Se développe en :
    ; push eax
    ; push ebx
    ; push ecx
    ; push edx

    ; pop en conséquence
    pop edx
    pop ecx
    pop ebx
    pop eax

    mov eax, 1
    mov ebx, 0
    int 0x80

Étiquettes locales dans les macros

Dans les macros, utilisez%%labelpour définir des étiquettes locales, en évitant les conflits d'étiquettes lors d'expansions multiples :

Exemple

; Étiquettes locales dans les macros

; Comparer deux valeurs et définir le minimum
%macro min_val 2
    mov eax, %1
    mov ebx, %2
    cmp eax, ebx
    jle %%skip                   ; ★ Étiquette locale, un nom unique est généré pour chaque expansion
    mov eax, ebx
%%skip:
%endmacro

; Si les étiquettes locales ne sont pas utilisées, des étiquettes skip dupliquées apparaissent après deux expansions
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

L'expansion d'une étiquette normale deux fois dans une macro provoque une erreur de collision de nom d'étiquette. Les étiquettes locales%%labelfont en sorte que NASM génère un nom d'étiquette unique pour chaque expansion (comme..@0001.skip), évitant les conflits.


Comparaison des macros et des procédures

FonctionnalitéMacroProcédure
Méthode d'implémentationExpansion de texte à la compilationCALL/RET à l'exécution
Surcharge d'exécutionAucune surcharge d'appel (inlining direct)A une surcharge CALL/RET (environ quelques cycles d'horloge)
Taille du codeChaque expansion augmente la taille du codeUne seule copie du code, appelée plusieurs fois
Types de paramètresTexte arbitraire (registres, immédiats, mémoire)Valeurs d'exécution
DébogageDifficile (aucune trace après expansion)Facile (dispose d'une pile d'appels de fonctions)
Scénarios applicablesCode court, fréquemment appelé et flexible au niveau des typesFonctions avec une logique complexe et une taille de code importante

Compilation conditionnelle : %if / %elif / %else / %endif

Le préprocesseur de macros prend en charge la compilation conditionnelle, qui peut sélectionner et générer du code différent en fonction des définitions de symboles :

Exemple

; Chemin du fichier : cond_compile.asm
; Exemple de compilation conditionnelle : modes débogage et release

%define DEBUG 1                  ; 1=mode débogage, 0=mode 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
        ; Mode débogage : afficher les informations de débogage
        mov eax, 4
        mov ebx, 1
        mov ecx, debug_msg
        mov edx, debug_len
        int 0x80
    %endif

    ; Logique métier normale
    mov eax, 4
    mov ebx, 1
    mov ecx, msg
    mov edx, msg_len
    int 0x80

    mov eax, 1
    mov ebx, 0
    int 0x80

Scénarios courants de compilation conditionnelle :

ScénarioExemple
Bascule Debug/Release%if DEBUG / %else / %endif
Adaptation à la plateforme%ifdef LINUX / %ifdef WINDOWS
Commutateurs de fonctionnalitésContrôler les fonctionnalités selon qu'un symbole est défini

%rep Bloc de répétition

%repUtilisé pour générer du code ou des données répétés :

Exemple

; exemple de bloc de répétition %rep

section .data
    ; Générer une table de correspondance de 256 octets
    ; 0, 1, 4, 9, 16, 25, ... (table des carrés)
    %assign i 0
    ; Ici %rep ne peut pas être utilisé pour générer une table des carrés pour des calculs complexes
    ; Exemple simple : générer une table ASCII pour 0-9
    digits: db '0', '1', '2', '3', '4', '5', '6', '7', '8', '9'

section .text
    global _start

_start:
    ; %rep répète des instructions dans le code
    mov eax, 0
    %rep 5                      ; Répéter 5 fois
        inc eax                  ; eax s'incrémente de 1 à chaque fois
    %endrep
    ; eax = 5

    mov ebx, eax
    mov eax, 1
    int 0x80

L'utilisation excessive de macros rend le code difficile à lire et à déboguer. Lorsque le corps de la macro dépasse 10 lignes, envisagez de passer à un appel de procédure. Dans les chemins critiques en termes de performances, l'effet d'inlining des macros courtes présente des avantages évidents.

Autres extensions