Layout de revista

Macros

O assembly escrito à mão está cheio de repetição. A mesma sequência curta de instruções aparece uma e outra vez, com pouca variação, e há poucas abstrações para reduzir o código repetitivo. Além disso, programar em assembly obriga a gerir valores sem semântica óbvia. Não há parâmetros com nome e a maioria dos detalhes da máquina subjacente tem de ser gerida manualmente pelo programador.

O NASM, o assembler usado pela track, oferece algumas ferramentas que podem ajudar o programador em ambos os problemas. Estas ferramentas atuam em tempo de assemblagem, antes de qualquer instrução chegar ao processador. Orientam o assembler na forma como deve reescrever o texto-fonte antes de este ser sequer traduzido para código máquina.

A mais importante destas ferramentas são as macros, que podem ser encaradas como uma receita para o assembler. 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, não são funções: não há call, nem ret, nem transferência de controlo 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)

Todas as ocorrências posteriores de WIDTH são substituídas por 8 antes da assemblagem. A substituição é textual, por isso o nome é substituído onde quer que apareça, seja num operando ou dentro de outra definição.

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

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

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

Os nomes definidos com %define distinguem maiúsculas de minúsculas. A variante %idefine faz com que o nome não distinga maiúsculas de minúsculas, caso se queira.

As macros de uma linha são úteis para dar significado a várias partes do código. Se usadas com cuidado, melhoram a legibilidade e reduzem a probabilidade de erros de escrita. Por exemplo, um registo com uma finalidade específica dentro de uma função pode ser definido por essa finalidade:

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

Macros de várias linhas

Toda uma sequência de código, com qualquer número de linhas, é capturada com %macro e fechada com %endmacro. Um número após o nome indica quantos argumentos a macro recebe, que pode ser zero. Quando são passados argumentos, estes são separados por uma vírgula (,):

%macro example_macro 0
...
%endmacro

Os argumentos das macros de várias linhas não têm nome. São referidos como %1, %2, e assim por diante, pela 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

Repara que os argumentos têm de ser sintaxe válida para as operações realizadas no corpo da macro. Aqui, mult_two eax, ecx e mult_two r8, r9 são ambos assemblados, mas mult_two eax, cl não, uma vez que imul eax, cl não está definido.

Etiquetas dentro de uma macro

Uma macro que define uma etiqueta comum quebra-se no momento em que é usada duas vezes, porque a etiqueta também seria definida duas vezes. Para usar etiquetas dentro de uma macro que possa ser chamada mais do que uma vez, é necessário prefixar essa etiqueta com %%. Isto instrui o assembler a dar a esta etiqueta um nome diferente e único em 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

Repetir em tempo de assemblagem

É possível repetir um bloco de código de uma linha com times. Isto é particularmente ú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 antes %rep:

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

Repara que o número de repetições é especificado logo após %rep e que há um %endrep para fechar o bloco repetido.

É comum usar um contador de tempo de assemblagem dentro de um bloco %rep, tal como um ciclo em tempo de execução usa um contador. Enquanto uma constante inteira de tempo de assemblagem pode ser declarada com equ, para variáveis inteiras de tempo de assemblagem usamos antes %assign. Ao contrário de %define, %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 de o pré-processador correr, o ciclo desaparece e restam quatro instruções add, com os valores imediatos 0, 1, 2 e 3 embutidos. Isto é o desenrolar de ciclos feito pelo assembler: sem registo contador e sem salto, apenas código linear.

Assemblagem condicional

Existem vários condicionais disponíveis para o pré-processador. Selecionam entre vários caminhos diferentes, expandindo o seu corpo no local, mas apenas quando a sua condição é 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

Dividir em ficheiros

As macros são frequentemente guardadas num ficheiro próprio e incluídas em cada fonte que precisa delas com %include:

%include "patterns.mac"

O ficheiro indicado é inserido tal e qual naquele ponto, antes da assemblagem, exatamente como se o seu conteúdo tivesse sido escrito ali. Isto mantém as definições num único local e permite que vários ficheiros-fonte as partilhem.

Se o ficheiro de macros puder ser assemblado de forma autónoma, deve ter a extensão .asm. Repara que as macros não têm ligação. Mesmo que o ficheiro de macros seja assemblado, as suas macros só são visíveis para outro ficheiro que o inclua com %include.

Caso contrário, um ficheiro usado apenas com %include pode ter qualquer extensão. A utilização de .asm ou .mac é uma convenção comum.