Instruções assembly x86
Entendendo algumas instruções do Assembly x86
Até agora já foram explicados alguns dos conceitos principais da linguagem Assembly da arquitetura x86, agora que já entendemos como a base funciona precisamos nos munir de algumas instruções para poder fazer códigos mais complexos. Pensando nisso vou listar aqui algumas instruções e uma explicação bem básica de como utilizá-las.

Formato da instrução

Já expliquei a sintaxe de uma instrução no NASM mas não expliquei o formato em si da instrução no código de máquina. Para simplificar uma instrução pode ter os seguintes operandos:
  • Um operando registrador
  • Um operando registrador OU operando na memória
  • Um operando imediato, que é um valor numérico que faz parte da instrução.
Basicamente são três tipos de operandos: Um registrador, valor na memória e um valor imediato. Um exemplo de cada um para ilustrar sendo mostrado como o segundo operando de MOV:
mov eax, ebx ; EBX = Registrador
mov eax, [ebx] ; [EBX] = Memória
mov eax, 65 ; 65 = Valor imediato
mov eax, "A" ; "A" = Valor imediato, mesmo que 65
Como demonstrado na linha 4 strings podem ser passadas como um operando imediato. O assembler irá converter a string em sua respectiva representação em bytes, só que é necessário ter atenção em relação ao tamanho da string que não pode ser maior do que o operando destino.
São três operandos diferentes e cada um deles é opcional, isto é, pode ou não ser utilizado pela instrução (opcional para a instrução e não para nós).
Repare que somente um dos operandos pode ser um valor na memória ou registrador, enquanto o outro é especificamente um registrador. É devido a isso que há a limitação de haver apenas um operando na memória, enquanto que o uso de dois operandos registradores é permitido.

Notação

Irei utilizar uma explicação simplificada aqui que irá deixar muita informação importante de fora.
As seguintes nomenclaturas serão utilizadas:
Nomenclatura
Significado
reg
Um operando registrador
r/m
Um operando registrador ou na memória
imm
Um operando imediato
addr
Denota um endereço, geralmente se usa um rótulo. Na prática é um valor imediato assim como o operando imediato.
Em alguns casos eu posso colocar um número junto a essa nomenclatura para especificar o tamanho do operando em bits. Por exemplo r/m16 indica um operando registrador/memória de 16 bits.
Em cada instrução irei apresentar a notação demonstrando cada combinação diferente de operandos que é possível utilizar. Lembrando que o operando destino é o mais à esquerda, enquanto que o operando fonte é o operando mais à direita.
Cada nome de instrução em Assembly é um mnemônico, que é basicamente uma abreviatura feita para fácil memorização. Pensando nisso leia cada instrução com seu nome extenso equivalente para lembrar o que ela faz. No título de cada instrução irei deixar após um "|" o nome extenso da instrução para facilitar nessa tarefa.

MOV | Move

mov reg, r/m
mov reg, imm
mov r/m, reg
mov r/m, imm
Copia o valor do operando fonte para o operando destino.
pseudo.c
destiny = source;

ADD

add reg, r/m
add reg, imm
add r/m, reg
add r/m, imm
Soma o valor do operando destino com o valor do operando fonte, armazenando o resultado no próprio operando destino.
pseudo.c
destiny = destiny + source;

SUB | Subtract

sub reg, r/m
sub reg, imm
sub r/m, reg
sub r/m, imm
Subtrai o valor do operando destino com o valor do operando fonte.
pseudo.c
destiny = destiny - source;

INC | Increment

inc r/m
Incrementa o valor do operando destino em 1.
pseudo.c
destiny++;

DEC | Decrement

dec r/m
Decrementa o valor do operando destino em 1.
pseudo.c
destiny--;

MUL | Multiplicate

mul r/m
Multiplica uma parte do mapeamento de RAX pelo operando fonte passado. Com base no tamanho do operando uma parte diferente de RAX será multiplicada e o resultado armazenado em um registrador diferente.
Operando 1
Operando 2
Destino
AL
r/m8
AX
AX
r/m16
DX:AX
EAX
r/m32
EDX:EAX
RAX
r/m64
RDX:RAX
No caso por exemplo de DX:AX, os registradores de 16 bits são usados em conjunto para representar um valor de 32 bits. Onde DX armazena os 2 bytes mais significativos do valor e AX os 2 bytes menos significativos.
pseudo.c
// Se operando de 8 bits
AX = AL * operand;
// Se operando de 16 bits
aux = AX * operand;
DX = (aux & 0xffff0000) >> 16;
AX = aux & 0x0000ffff;

DIV | Divide

div r/m
Seguindo uma premissa inversa de MUL, essa instrução faz a divisão de um valor pelo operando fonte passado e armazena o quociente e a sobra dessa divisão.
Operando 1
Operando 2
Destino quociente
Destino sobra
AX
r/m8
AL
AH
DX:AX
r/m16
AX
DX
EDX:EAX
r/m32
EAX
EDX
RDX:RAX
r/m64
RAX
RDX
pseudo.c
// Se operando de 8 bits
AL = AX / operand;
AH = AX % operand;

LEA | Load Effective Address

lea reg, mem
Calcula o endereço efetivo do operando fonte e armazena o resultado do cálculo no registrador destino. Ou seja, ao invés de ler o valor no endereço do operando na memória o próprio endereço resultante do cálculo de endereço será armazenado no registrador. Exemplo:
mov rbx, 5
lea rax, [rbx + 7]
; Aqui RAX teria o valor 12

AND

and reg, r/m
and reg, imm
and r/m, reg
and r/m, imm
Faz uma operação E bit a bit nos operandos e armazena o resultado no operando destino.
pseudo.c
destiny = destiny & source;

OR

or reg, r/m
or reg, imm
or r/m, reg
or r/m, imm
Faz uma operação OU bit a bit nos operandos e armazena o resultado no operando destino.
pseudo.c
destiny = destiny | source;

XOR | Exclusive OR

xor reg, r/m
xor reg, imm
xor r/m, reg
xor r/m, imm
Faz uma operação OU Exclusivo bit a bit nos operandos e armazena o resultado no operando destino.
pseudo.c
destiny = destiny ^ source;

XCHG | Exchange

xchg reg, r/m
xchg r/m, reg
O operando 2 recebe o valor do operando 1 e o operando 1 recebe o valor anterior do operando 2. Fazendo assim uma troca nos valores dos dois operandos. Repare que diferente das instruções anteriores essa modifica também o valor do segundo operando.
auxiliary = destiny;
destiny = source;
source = auxiliary;

XADD | Exchange and Add

xadd r/m, reg
O operando 2 recebe o valor do operando 1 e, em seguida, o operando 1 é somado com o valor anterior do operando 2. Basicamente preserva o valor anterior do operando 1 no operando 2 ao mesmo tempo que faz um ADD nele.
pseudo.c
auxiliary = source;
source = destiny;
destiny = destiny + auxiliary;
Essa instrução é equivalente a seguinte sequência de instruções:
xchg rax, rbx
add rax, rbx

SHL | Shift Left

shl r/m
shl r/m, imm
shl r/m, CL
Faz o deslocamento de bits do operando destino para a esquerda com base no número especificado no operando fonte. Se o operando fonte não é especificado então faz o shift left apenas 1 vez.
pseudo.c
destiny = destiny << 1; // Se: shl r/m
destiny = destiny << source; // Nos outros casos

SHR | Shift Right

shr r/m
shr r/m, imm
shr r/m, CL
Mesmo caso que SHL porém faz o deslocamento de bits para a direita.
pseudo.c
destiny = destiny >> 1; // Se: shr r/m
destiny = destiny >> source; // Nos outros casos

CMP | Compare

cmp r/m, imm
cmp r/m, reg
cmp reg, r/m
Compara o valor dos dois operandos e define RFLAGS de acordo.
pseudo.c
RFLAGS = compare(operand1, operand2);

SETcc | Set byte if condition

SETcc r/m8
Define o valor do operando de 8 bits para 1 ou 0 dependendo se a condição for atendida (1) ou não (0). Assim como no caso dos jumps condicionais, o 'cc' aqui denota uma sigla para uma condição. Cuja a condição pode ser uma das mesmas utilizadas nos jumps. Exemplo:
sete al
; Se RFLAGS indica um valor igual: AL = 1. Se não: AL = 0
pseudo.c
if (verify_rflags(condition) == true)
{
destiny = 1;
}
else
{
destiny = 0;
}

CMOVcc | Conditional Move

CMOVcc reg, r/m
Basicamente uma instrução MOV condicional. Só irá definir o valor do operando destino caso a condição seja atendida.
pseudo.c
if (verify_rflags(condition) == true)
{
destiny = source;
}

NEG | Negate

neg r/m
Inverte o sinal do valor numérico do operando.
pseudo.c
destiny = -destiny;

NOT

not r/m
Faz uma operação NÃO bit a bit no operando.
pseudo.c
destiny = ~destiny;

MOVSB/MOVSW/MOVSD/MOVSQ | Move String

movsb ; byte (1 byte)
movsw ; word (2 bytes)
movsd ; double word (4 bytes)
movsq ; quad word (8 bytes)
Copia um valor do tamanho de um byte, word, double word ou quad word a partir do endereço apontado por RSI (Source Index) para o endereço apontado por RDI (Destiny Index). Depois disso incrementa o valor dos dois registradores com o tamanho em bytes do dado que foi movido.
pseudo.c
// Se MOVSW
word [RDI] = word [RSI];
RDI = RDI + 2;
RSI = RSI + 2;

CMPSB/CMPSW/CMPSD/CMPSQ | Compare String

cmpsb ; byte (1 byte)
cmpsw ; word (2 bytes)
cmpsd ; double word (4 bytes)
cmpsq ; quad word (8 bytes)
Compara os valores na memória apontados por RDI e RSI, depois incrementa os registradores com o tamanho em bytes do dado.
pseudo.c
// CMPSW
RFLAGS = compare(word [RDI], word [RSI]);
RDI = RDI + 2;
RSI = RSI + 2;

LODSB/LODSW/LODSD/LODSQ | Load String

lodsb ; byte (1 byte)
lodsw ; word (2 bytes)
lodsd ; double word (4 bytes)
lodsq ; quad word (8 bytes)
Copia o valor na memória apontado por RSI para uma parte do mapeamento de RAX equivalente ao tamanho do dado, e depois incrementa RSI com o tamanho do valor.
pseudo.c
// LODSW
AX = word [RSI];
RSI = RSI + 2;

SCASB/SCASW/SCASD/SCASQ | Scan String

scasb ; byte (1 byte)
scasw ; word (2 bytes)
scasd ; double word (4 bytes)
scasq ; quad word (8 bytes)
Compara o valor em uma parte mapeada de RAX com o valor na memória apontado por RDI e depois incrementa RDI de acordo.
pseudo.c
// SCASW
RFLAGS = compare(AX, word [RDI]);
RDI = RDI + 2;

STOSB/STOSW/STOSD/STODQ | Store String

stosb ; byte (1 byte)
stosw ; word (2 bytes)
stosd ; double word (4 bytes)
stosq ; quad word (8 bytes)
Copia o valor de uma parte mapeada de RAX e armazena na memória apontada por RDI, depois incrementa RDI de acordo.
pseudo.c
// STOSW
word [RDI] = AX;
RDI = RDI + 2;

LOOP/LOOPE/LOOPNE

pseudo.c
loop addr8
loope addr8
loopne addr8
Essas instruções são utilizadas para gerar procedimentos de laço (loop) usando o registrador RCX como contador. Elas primeiro decrementam o valor de RCX e comparam o mesmo com o valor zero. Se RCX for diferente de zero a instrução faz um salto para o endereço passado como operando, senão o fluxo de código continua normalmente.
No caso de loope e loopne os sufixos indicam a condição de igual e não igual respectivamente. Ou seja, além da comparação do valor de RCX elas também verificam o valor de RFLAGS como uma condição extra.
pseudo.c
// loop
RCX = RCX - 1;
if(RCX != 0)
{
goto operand;
}
// loope
RCX = RCX - 1;
if(RCX != 0 && verify_rflags(EQUAL) == true)
{
goto operand;
}
// loopne
RCX = RCX - 1;
if(RCX != 0 && verify_rflags(EQUAL) == false)
{
goto operand;
}

NOP | No Operation

nop
Não faz nenhuma operação... Sério, não faz nada. Essa instrução normalmente é utilizada apenas como um "preenchimento" por compiladores afim de alinhar o endereço de código por motivos de otimização.
pseudo.c
EAX = EAX;
Não cabe a esse livro explicar porque esse alinhamento melhora a performance do código mas se estiver curioso estude à respeito do cache do processador e cache line. Para simplificar um desvio de código para um endereço que esteja próximo ao início de uma linha de cache é mais performático.
Se você for um escovador de bits sugiro ler à respeito no manual de otimização da Intel no tópico 3.4.1.4 Code Alignment.