In assembly language, macros are a powerful feature that allows programmers to define a sequence of instructions or code that can be reused multiple times throughout a program.

What is an Assembly Macro?

An assembly macro is a set of instructions or code patterns that can be reused multiple times throughout a program. Macros allow you to define complex sequences of code and invoke them with a single command, which the assembler then expands into the full code sequence.

A macro is a block of code defined once and can be reused multiple times throughout the program.

When a macro is called, the assembler replaces the macro call with the actual code defined within the macro. This inline expansion of code helps in reducing manual repetition of common tasks, making the code more maintainable.

Macros are defined and used in various assemblers, such as NASM (Netwide Assembler) and MASM (Microsoft Macro Assembler). The syntax for macros differs slightly between assemblers but follows a similar basic concept.

Structure of Macro in NASM

To define a macro in NASM, you use the %macro directive followed by the macro name and the number of parameters. The macro body is written between %macro and %endmacro.

A macro in NASM typically follows this structure:

%macro MACRO_NAME  [number_of_parameters]
    ; Macro body: sequence of assembly instructions
%endmacro

• %macro and %endmacro are directives that define the start and end of a macro, respectively.
• MACRO_NAME is the name of the macro, which you will use to invoke it.
• number_of_parameters specifies the number of parameters the macro accepts. This is optional; if omitted, the macro takes no parameters.

Example of a Simple Macro

%macro ADD_TWO_NUMBERS 3
    mov %3, %1       ; Move the value of the first parameter to the result
    add %3, %2       ; Add the value of the second parameter to the result
%endmacro

section .text
    global _start

_start:
    mov eax, 5
    mov ebx, 10
    ADD_TWO_NUMBERS eax, ebx, ecx   ; ecx = eax + ebx = 15

    ; Exit the program
    mov eax, 60
    xor edi, edi
    syscall

When the assembler processes this code, it will replace the ADD_TWO_NUMBERS macro call with:

mov ecx, eax
add ecx, ebx

Parameters in Macros

Macros can take parameters, which are placeholders for values or registers that you pass when invoking the macro. The parameters are referenced within the macro body using %1, %2, and so on, corresponding to the order of parameters.

Example with Parameters:

%macro MOVE_AND_ADD 2
    mov %1, %2
    add %1, %2
%endmacro

Usage:

MOVE_AND_ADD eax, ebx  ; eax = eax + ebx

Conditional Assembly in Macros

NASM allows you to incorporate conditional logic within macros using %if, %else, and %endif directives. This can be useful when you want a macro to behave differently based on specific conditions.

Example with Conditional Assembly:

%macro CHECK_AND_ADD 3
    %if %1 > %2
        mov %3, %1
        add %3, %2
    %else
        mov %3, %2
        add %3, %1
    %endif
%endmacro

Usage:

CHECK_AND_ADD eax, ebx, ecx  ; ecx = eax + ebx or ebx + eax depending on the condition

In this example, the macro checks which of the two registers (%1 or %2) holds the greater value and adds them accordingly.

Advantages of Using Macros

1. Code Reusability: By defining a macro, you can reuse the same code in multiple places without rewriting it.
2. Enhanced Readability: Macros with meaningful names can make the code more readable and easier to understand.
3. Simplified Maintenance: Changes to a repetitive sequence of instructions need to be made only in the macro definition, not throughout the codebase.
4. Reduced Human Error: Reducing the need to write repetitive code manually can help avoid mistakes.

Macros vs. Procedures

While both macros and procedures (functions) in NASM allow code reuse, they serve different purposes and have distinct characteristics:

• Macros: Inline code expansion means no overhead for function calls, but can lead to code bloat if overused.
• Procedures: They involve function calls, which include stack operations (pushing/popping registers), but they can save memory by avoiding code repetition.

Use macros when you need to optimize for performance and when the code sequence is relatively small. Use procedures when you need to optimize for memory usage and maintainability.

Pitfalls of Using Macros

1. Code Bloat: Since macros are expanded inline, extensive use can result in a larger executable, which can negatively impact performance.
2. Debugging Complexity: Debugging can become challenging because the macro expansion hides the actual instructions that are executed.
3. Limited Scope: Macros don’t have their own scope, meaning variables within macros can conflict with those in the calling code.

Advanced Macro Features

NASM provides several advanced features for macros, such as local labels and repeat loops:

• Local Labels: Use %% before a label name to create a label local to a macro. This prevents label conflicts when the macro is expanded multiple times.

%macro LOOP_MACRO 2
    %%loop_start:
        mov %1, [%2 + %1]
        dec %1
        jnz %%loop_start
%endmacro

• Repeat Loops: Use %rep and %endrep to repeat a sequence of instructions a specific number of times.

%macro REPEAT_MOV 2
    %rep 5
        mov %1, %2
    %endrep
%endmacro