Black Jack

Condicionais

Flags de registrador (RFLAGs)

Existe um registrador especial chamado rflags. Seus bits funcionam como flags para diversas 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, elas 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. Ela 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 do primeiro e define as flags de acordo com o resultado.

Se A é o primeiro operando e B, o segundo:

Ramificação

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

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

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

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

Salto incondicional

A instrução jmp transfere incondicionalmente a execução do programa para outro ponto do código. Seu único operando é um rótulo que contém o endereço do ponto onde a execução continuará.

Considere, 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. Isso define o valor em rax como 5 nesse ponto.

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

Depois de end, a próxima instrução é ret, que transfere a execução de volta para a função chamadora.

Repare que, como add rax, 10 está localizada depois de jmp end e antes de end, ela nunca é executada. O valor de rax quando fn retorna é 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 for satisfeita. 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 ela está limpa.

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

Existem muitos sufixos, e muitos deles testam a mesma condição que outro. Alguns se referem 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 referir ao seu significado em uma instrução cmp. Por exemplo:

É possível adicionar 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. Elas têm a mesma sintaxe, mas com um n antes do sufixo.

Por exemplo, jnz salta quando ZF não está definida. Da mesma forma, 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 arquivo-fonte, eles não são locais a uma função. Então é 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 dele. Essa 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 esse rótulo de qualquer lugar do código usando o nome completo do rótulo, por exemplo, jmp fn1.example.

No entanto, um salto que usa a parte do rótulo a partir do ponto será feito para o rótulo dentro da função superior. Por exemplo, .example se comporta 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