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
; 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
; 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
; 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
; 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é | Macro | Procédure |
|---|---|---|
| Méthode d'implémentation | Expansion de texte à la compilation | CALL/RET à l'exécution |
| Surcharge d'exécution | Aucune surcharge d'appel (inlining direct) | A une surcharge CALL/RET (environ quelques cycles d'horloge) |
| Taille du code | Chaque expansion augmente la taille du code | Une seule copie du code, appelée plusieurs fois |
| Types de paramètres | Texte arbitraire (registres, immédiats, mémoire) | Valeurs d'exécution |
| Débogage | Difficile (aucune trace après expansion) | Facile (dispose d'une pile d'appels de fonctions) |
| Scénarios applicables | Code court, fréquemment appelé et flexible au niveau des types | Fonctions 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
; 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énario | Exemple |
|---|---|
| Bascule Debug/Release | %if DEBUG / %else / %endif |
| Adaptation à la plateforme | %ifdef LINUX / %ifdef WINDOWS |
| Commutateurs de fonctionnalités | Contrô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
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
Autres extensionsL'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.