Assemblage - Macros

L'écriture d'une macro est un autre moyen d'assurer une programmation modulaire en langage assembleur.

Une macro est une séquence d'instructions, assignée par un nom et pouvant être utilisée n'importe où dans le programme.
Dans NASM, les macros sont définies avec %macro et %endmacro directives.
La macro commence par la directive% macro et se termine par la directive% endmacro.

La syntaxe pour la définition de macro -

%macro macro_name  number_of_params
<macro body>
%endmacro

Où, number_of_params spécifie les paramètres numériques , macro_name spécifie le nom de la macro.

La macro est appelée en utilisant le nom de la macro avec les paramètres nécessaires. Lorsque vous devez utiliser une séquence d'instructions plusieurs fois dans un programme, vous pouvez placer ces instructions dans une macro et l'utiliser au lieu d'écrire les instructions tout le temps.

Par exemple, un besoin très courant pour les programmes est d'écrire une chaîne de caractères à l'écran. Pour afficher une chaîne de caractères, vous avez besoin de la séquence d'instructions suivante -

mov	edx,len	    ;message length
mov	ecx,msg	    ;message to write
mov	ebx,1       ;file descriptor (stdout)
mov	eax,4       ;system call number (sys_write)
int	0x80        ;call kernel

Dans l'exemple ci-dessus d'affichage d'une chaîne de caractères, les registres EAX, EBX, ECX et EDX ont été utilisés par l'appel de fonction INT 80H. Ainsi, chaque fois que vous devez afficher à l'écran, vous devez sauvegarder ces registres sur la pile, appeler INT 80H puis restaurer la valeur d'origine des registres de la pile. Ainsi, il peut être utile d'écrire deux macros pour enregistrer et restaurer les données.

Nous avons observé que certaines instructions comme IMUL, IDIV, INT, etc., ont besoin que certaines des informations soient stockées dans certains registres particuliers et retournent même des valeurs dans certains registres spécifiques. Si le programme utilisait déjà ces registres pour conserver des données importantes, les données existantes de ces registres doivent être sauvegardées dans la pile et restaurées après l'exécution de l'instruction.

Exemple

L'exemple suivant montre la définition et l'utilisation de macros -

; A macro with two parameters
; Implements the write system call
   %macro write_string 2 
      mov   eax, 4
      mov   ebx, 1
      mov   ecx, %1
      mov   edx, %2
      int   80h
   %endmacro
 
section	.text
   global _start            ;must be declared for using gcc
	
_start:                     ;tell linker entry point
   write_string msg1, len1               
   write_string msg2, len2    
   write_string msg3, len3  
	
   mov eax,1                ;system call number (sys_exit)
   int 0x80                 ;call kernel

section	.data
msg1 db	'Hello, programmers!',0xA,0xD 	
len1 equ $ - msg1			

msg2 db 'Welcome to the world of,', 0xA,0xD 
len2 equ $- msg2 

msg3 db 'Linux assembly programming! '
len3 equ $- msg3

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant -

Hello, programmers!
Welcome to the world of,
Linux assembly programming!