Blackjack

Condicionais

RFLAGs

Existe um registo especial chamado rflags. Os seus bits funcionam como flags para várias condições.

Algumas delas estão listadas abaixo:

Instruções de comparação

As flags em rflags não são modificadas diretamente. Em vez disso, são definidas por muitas instruções diferentes.

Por exemplo, ZF é definida por muitas operações aritméticas ou bit a bit quando o resultado é zero.

Uma das instruções mais comuns usadas para testar condições é cmp. Recebe dois operandos e atualiza as flags, mas não modifica os seus operandos.

A instrução CMP

A instrução cmp subtrai o segundo operando ao primeiro e define as flags de acordo com o resultado.

Se A é o primeiro operando e B o segundo:

Ramificação

Por predefinição, o código em x86-64 é executado sequencialmente de cima para baixo.

Mas há muitas situações em que é necessário alterar este comportamento. Por exemplo, para executar um conjunto diferente de instruções em resposta a uma condição.

Nas linguagens de alto nível, isto costuma ser feito com abstrações como as condicionais if...else. No entanto, essas não existem em x86-64.

Em vez disso, o x86-64 fornece instruções que transferem efetivamente a execução para outro ponto do código. Isto chama-se branching.

Salto incondicional

A instrução jmp transfere incondicionalmente a execução do programa para outro ponto do código. O seu único operando é um rótulo que tem o endereço do ponto onde a execução vai continuar.

Considera, por exemplo, a seguinte função:

fn:
    mov rax, 5
    jmp end

    add rax, 10
end:
    ret

Quando fn é chamada, a execução começa em mov rax, 5. Isto define o valor em rax como 5 nesse ponto.

A instrução seguinte é jmp end, que transfere a execução para o rótulo end.

Depois de end, a instrução seguinte é ret, que transfere a execução de volta para a função que a chamou.

Repara que, como add rax, 10 está depois de jmp end e antes de end, nunca é executada. O valor de rax quando fn regressa é 5.

Salto condicional

A família de instruções jcc transfere a execução do programa para outro ponto apenas se uma condição específica se verificar. Caso contrário, a execução continua sequencialmente.

Cada condição corresponde a uma ou mais flags em rflags. Algumas variantes de jcc testam se uma flag está definida, outras testam se está limpa.

O cc em jcc não é literal, mas refere-se ao sufixo específico associado à flag testada.

Há muitos sufixos e muitos deles testam a mesma condição que outro. Alguns referem-se diretamente a uma flag, de modo que a instrução salta para um rótulo se a flag específica estiver definida:

Muitos outros são escolhidos para se referirem ao seu significado numa instrução cmp. Por exemplo:

É possível acrescentar e depois de l, b, g ou a para incluir a igualdade na condição:

cmp rcx, r8
jge two      ; this jumps to 'two' if rcx is greater than, or equal to, r8 in a signed comparison
jbe two      ; this jumps to 'two' if rcx is lesser than, or equal to, r8 in an unsigned comparison

Para todos os sufixos, existem variantes que verificam o comportamento oposto. Têm a mesma sintaxe, mas com um n antes do sufixo.

Por exemplo, jnz salta quando ZF não está definida. Do mesmo modo, jnae salta quando A não é >= B (A e B interpretados como inteiros sem sinal).

Rótulos locais

Os rótulos são visíveis em todo o ficheiro fonte; não são locais a uma função. Por isso, é impossível reutilizar o nome de um rótulo.

Para imitar o comportamento de um rótulo local, o NASM tem uma notação especial para um rótulo declarado com um ponto (.) antes do nome. Esta notação define um rótulo que inclui implicitamente o nome do rótulo anterior sem ponto:

section .text
fn1:
    ...
.example: ; this is fn1.example
    ...
    ret

fn2:
    ...
.example: ; this is fn2.example
    ...
    ret

Ainda é possível saltar para este rótulo a partir de qualquer ponto do código, usando o nome completo do rótulo, por exemplo, jmp fn1.example.

No entanto, um salto que use a parte do rótulo a partir do ponto será feito para o rótulo dentro da função superior. Por exemplo, .example comporta-se como se fosse local à função:

section .text
fn1:
    ...
.example:
    ...
    jmp .example ; this jumps to fn1.example

fn2:
    ...
.example:
    ...
    jmp .example ; this jumps to fn2.example