Layout de revista

Macros

O código assembly escrito à mão é cheio de repetição. A mesma sequência curta de instruções aparece de novo e de novo, com pouca variação, e há poucas abstrações para reduzir o código repetitivo. Além disso, programar em assembly exige gerenciar valores sem semântica óbvia. Não há parâmetros nomeados, e a maior parte dos detalhes do funcionamento interno da máquina precisa ser tratada manualmente por quem programa.

O NASM, o montador usado pela trilha, oferece algumas ferramentas que podem ajudar quem programa com esses dois problemas. Essas ferramentas atuam em tempo de montagem, antes que qualquer instrução chegue ao processador. Elas orientam o montador sobre como reescrever o código-fonte antes mesmo de ele ser convertido em código de máquina.

A mais importante dessas ferramentas são as macros, que podem ser pensadas como uma receita para o montador. Elas são expandidas no local onde são usadas, como se o código tivesse sido escrito ali à mão.

As macros podem receber vários tokens literais como parâmetros, o que as torna reutilizáveis em contextos diferentes. No entanto, elas não são funções: não há call, nem ret, nem transferência de controle para outro ponto do código.

Macros de uma linha

A definição mais simples dá um nome a um valor ou a uma expressão curta com %define:

%define WIDTH 8
%define BUFFER_SIZE (WIDTH * 16)

Toda ocorrência posterior de WIDTH é substituída por 8 antes da montagem. A substituição é textual, então o nome é substituído onde quer que apareça, seja em um operando, seja dentro de outra definição.

Um %define também pode receber parâmetros nomeados, comportando-se como uma pequena função inline:

%define double(x) ((x) + (x))

    mov eax, double(WIDTH)   ; assembled as mov eax, ((8) + (8))

Nomes definidos com %define diferenciam maiúsculas de minúsculas. A variante %idefine torna o nome insensível a maiúsculas e minúsculas, caso isso seja desejado.

Macros de uma linha são úteis para dar sentido a várias partes do código. Se usadas com cuidado, elas melhoram a legibilidade e reduzem a chance de erros de digitação. Por exemplo, um registrador que tem uma finalidade específica dentro de uma função pode ser definido pela sua finalidade:

%define COUNTER rcx
    ...
.loop:
    ...
    dec COUNTER
    jnz .loop
    ...

Macros de várias linhas

Uma sequência inteira de código, com qualquer número de linhas, é capturada com %macro e fechada com %endmacro. Um número depois do nome indica quantos argumentos a macro recebe, podendo ser zero. Quando argumentos são passados, eles são separados por vírgula (,):

%macro example_macro 0
...
%endmacro

Argumentos em macros de várias linhas não têm nome. Eles são referenciados como %1, %2 e assim por diante, na ordem em que são passados:

; Multiplies two values, returning the result in the first argument
%macro mult_two 2        ; %1 = accumulator, %2 = value
    imul %1, %2
%endmacro

    mult_two eax, ecx    ; multiplies eax and ecx and returns the result into eax
    mult_two r8, r9      ; multiplies r8 and r9 and returns the result into r8

Repare que os argumentos precisam ter sintaxe válida para as operações realizadas no corpo da macro. Aqui mult_two eax, ecx e mult_two r8, r9 montam sem problema, mas mult_two eax, cl não montaria, já que imul eax, cl não está definido.

Rótulos dentro de uma macro

Uma macro que define um rótulo comum quebra no momento em que é usada duas vezes, porque o rótulo também seria definido duas vezes. Para usar rótulos dentro de uma macro que pode ser chamada mais de uma vez, é necessário prefixar esse rótulo com %%. Isso instrui o montador a dar a esse rótulo um nome diferente e único a cada expansão:

; clobbers rcx
%macro clear_n 2         ; %1 = base address, %2 = count of dwords to clear
    xor ecx, ecx
%%loop:
    mov dword [%1 + rcx*4], 0
    inc ecx
    cmp ecx, %2          ; %2 is compared with ecx: it is an immediate or a 32-bit operand
    jb %%loop
%endmacro

    clear_n rdi, 4       ; gets its own %%loop
    clear_n rsi, 8       ; a different %%loop, no clash

Repetição em tempo de montagem

É possível repetir um bloco de código de uma linha usando times. Isso é especialmente útil ao declarar valores repetidos na memória:

section .data
negative_block: times 16 db -1
; this assembles to 16 db -1 in sequence, i.e., an array of 16 bytes, all equal to -1

Para repetir código de várias linhas, podemos usar %rep:

%rep 2          ; number of repetitions: 2
    add rcx, 32
    mov dword [rsi + rcx], 0
%endrep

Repare que o número de repetições é especificado logo depois de %rep, e há um %endrep para fechar o bloco repetido.

É comum usar um contador de tempo de montagem dentro de um bloco %rep, muito parecido com um laço em tempo de execução que usa um contador. Enquanto uma constante inteira de tempo de montagem pode ser declarada com equ, para variáveis inteiras de tempo de montagem usamos %assign. Diferente de %define, o %assign é avaliado imediatamente para um número e pode ser reatribuído:

    xor eax, eax
%assign i 0
%rep 4
    add eax, i           ; add 0, then 1, then 2, then 3
%assign i i + 1
%endrep

Depois que o pré-processador roda, o laço desaparece e restam quatro instruções add, com os valores imediatos 0, 1, 2 e 3 já embutidos. Isso é o desenrolar de laço feito pelo montador: sem registrador de contador e sem desvio, apenas código linear.

Montagem condicional

O pré-processador oferece várias condicionais. Elas escolhem entre vários caminhos diferentes e expandem o corpo no próprio local, mas só quando sua condição for verdadeira.

%if ... %elif ... %else ... %endif selecionam um ramo a partir de um teste numérico:

%if WIDTH > 4
    mov eax, 2
%elif WIDTH > 2
    mov eax, 1
%else
    mov eax, 0
%endif

Dividindo em arquivos

As macros costumam ficar em um arquivo próprio e são trazidas para cada fonte que precisa delas com %include:

%include "patterns.mac"

O arquivo indicado é inserido literalmente nesse ponto, antes da montagem, exatamente como se o conteúdo dele tivesse sido digitado ali. Isso mantém as definições em um só lugar e permite que vários arquivos-fonte as compartilhem.

Se o arquivo de macros puder ser montado sozinho, ele deve ter a extensão .asm. Repare que macros não têm ligação. Mesmo que o arquivo de macros seja montado, suas macros só ficam visíveis para outro arquivo que faça %include dele.

Caso contrário, um arquivo destinado apenas a %include pode ter qualquer extensão. Usar .asm ou .mac é uma convenção comum.