Folha de consulta de Assembly
Última atualização
Estrutura do programa
Um programa sem a biblioteca C começa no rótulo informado ao linker, geralmente _start.
| Elemento | Código |
|---|---|
| Seção para dados fixos | section .data |
| Seção para buffers zerados | section .bss |
| Seção para instruções | section .text |
| Tornar o ponto de entrada visível para o linker | global _start |
| Um rótulo (um endereço com nome) | _start: |
| Comentário | ; everything after a semicolon |
| Encerrar o programa com código de saída 0 | mov rax, 60 → mov rdi, 0 → syscall |
Registradores
Dezesseis registradores de uso geral de 64 bits. Cada um tem nomes menores para os seus 32, 16 e 8 bits inferiores.
| Registrador e uso comum | Nomes de 64 / 32 / 16 / 8 bits |
|---|---|
| Acumulador, número da chamada de sistema, valor de retorno | rax eax ax al |
| Base, preservado entre chamadas de função | rbx ebx bx bl |
| Contador, 4º argumento de função | rcx ecx cx cl |
Dados, 3º argumento, metade superior de mul e div | rdx edx dx dl |
| Índice de origem, 2º argumento | rsi esi si sil |
| Índice de destino, 1º argumento | rdi edi di dil |
| Ponteiro de pilha, topo da pilha | rsp esp sp spl |
| Ponteiro base, quadro de pilha | rbp ebp bp bpl |
Registradores extras, mostrados com r8; r9 a r15 seguem o mesmo padrão | r8 r8d r8w r8b |
| Ponteiro de instrução, endereço da próxima instrução | rip |
Flags definidas por cmp, test e aritmética | rflags |
Diretivas de dados
Diretivas são lidas pelo montador e reservam ou nomeiam memória; elas não são instruções.
| Significado | Código |
|---|---|
| Definir bytes: uma string e uma quebra de linha | msg db "Hello", 10 |
| Definir uma word de 16 bits | year dw 2026 |
| Definir uma doubleword de 32 bits | count dd 1000 |
| Definir uma quadword de 64 bits | big dq 123456789 |
Reservar 64 bytes zerados (em .bss) | buffer resb 64 |
| Reservar 10 quadwords | table resq 10 |
| Dar nome a uma constante | max equ 100 |
| Tamanho dos dados logo acima | len equ $ - msg |
| Repetir uma definição | zeros times 8 db 0 |
Movendo dados
O destino vem primeiro. Colchetes significam a memória naquele endereço.
| Operação | Código |
|---|---|
| Número para um registrador | mov rax, 42 |
| Registrador para registrador | mov rbx, rax |
| Endereço de um rótulo para um registrador | mov rsi, msg |
| Ler 8 bytes da memória | mov rax, [big] |
| Gravar um registrador na memória | mov [big], rax |
| Gravar um byte, com o tamanho explícito | mov byte [buffer], 10 |
| Ler a memória em registrador mais deslocamento | mov al, [rsi + 1] |
| Indexado: base + índice * escala + deslocamento | mov rax, [table + rcx * 8] |
| Calcular um endereço sem ler a memória | lea rax, [rsi + rcx * 2] |
| Carregar um byte e zerar o resto do registrador | movzx eax, byte [rsi] |
| Trocar dois registradores | xchg rax, rbx |
Aritmética e lógica
Instruções de dois operandos gravam o resultado no primeiro operando. mul, div e idiv também usam rax e rdx implicitamente. O efeito nas flags varia: not não altera as flags, e div e idiv as deixam indefinidas.
| Operação | Código |
|---|---|
| Somar | add rax, rbx |
| Subtrair | sub rax, 5 |
| Somar 1 / subtrair 1 | inc rcx / dec rcx |
| Multiplicação com sinal em um registrador | imul rax, rbx |
Multiplicação sem sinal: rdx:rax = rax * rbx | mul rbx |
Divisão sem sinal do valor em rax por rbx: zere rdx antes; quociente em rax, resto em rdx | xor rdx, rdx → div rbx |
Divisão com sinal: estender o sinal de rax para rdx antes | cqo → idiv rbx |
| Inverter o sinal | neg rax |
| Bit a bit and, or, xor, not | and rax, 0xff / or rax, rbx / xor rax, rbx / not rax |
| Zerar um registrador (curto e rápido) | xor eax, eax |
| Deslocar para a esquerda (multiplica por 2 a cada bit) | shl rax, 3 |
| Deslocar para a direita: sem sinal / com sinal | shr rax, 1 / sar rax, 1 |
Comparar e saltar
cmp subtrai sem guardar o resultado e define as flags; um salto condicional então as lê.
| Operação | Código |
|---|---|
| Comparar dois valores | cmp rax, rbx |
| Testar bits (and sem guardar), muitas vezes para checar se é zero | test rax, rax |
| Saltar sempre | jmp done |
| Saltar se igual / zero | je done / jz done |
| Saltar se diferente / não zero | jne loop_start / jnz loop_start |
| Com sinal: maior, maior ou igual, menor, menor ou igual | jg / jge / jl / jle |
| Sem sinal: acima, acima ou igual, abaixo, abaixo ou igual | ja / jae / jb / jbe |
| Repetir 10 vezes com um contador | mov rcx, 10 → again: → dec rcx → jnz again |
| Copiar só se a condição for verdadeira (sem salto) | cmovg rax, rbx |
Pilha e funções
A pilha cresce para baixo: push diminui rsp em 8, pop aumenta.
| Operação | Código |
|---|---|
| Empilhar um registrador / desempilhá-lo | push rbx / pop rbx |
| Chamar uma função (empilha o endereço de retorno) | call print_line |
| Voltar para quem chamou | ret |
| Reservar 32 bytes de espaço local | sub rsp, 32 |
| Liberar esse espaço | add rsp, 32 |
| Montar um quadro de pilha | push rbp → mov rbp, rsp |
| Desfazer o quadro de pilha | mov rsp, rbp → pop rbp |
| Argumentos, em ordem (System V, Linux e macOS) | rdi rsi rdx rcx r8 r9 |
Registradores que uma função deve restaurar antes de ret | rbx rbp r12 r13 r14 r15 |
Chamadas de sistema do Linux
Coloque o número em rax e os argumentos em rdi, rsi, rdx, r10, r8, r9, depois execute syscall. O resultado volta em rax; um valor negativo é um código de erro.
| Chamada | Registradores |
|---|---|
read(fd, buffer, count) | rax = 0 rdi = fd rsi = buffer rdx = count |
write(fd, buffer, count) | rax = 1 rdi = fd rsi = buffer rdx = count |
open(path, flags, mode) | rax = 2 rdi = path rsi = flags rdx = mode |
close(fd) | rax = 3 rdi = fd |
exit(code) | rax = 60 rdi = code |
| Entrada, saída e erro padrão | fd 0 fd 1 fd 2 |
| Registradores que o kernel sobrescreve | rcx r11 |
Montar, executar e inspecionar
Em uma máquina Linux com o NASM e as ferramentas GNU instalados.
| Tarefa | Comando |
|---|---|
| Montar em um arquivo objeto | nasm -f elf64 main.asm -o main.o |
| Linkar em um programa | ld main.o -o main |
| Executar e mostrar o código de saída | ./main; echo $? |
| Desmontar, sintaxe Intel | objdump -d -M intel main |
| Executar passo a passo em um depurador | gdb ./main |
| Ver o Assembly que um compilador C gera | gcc -S -O2 -masm=intel file.c |
Os registradores, instruções e chamadas de sistema que você mais usa ao escrever Assembly x86-64, em uma página. Cada linha está em sintaxe NASM (ordem de operandos da Intel, destino primeiro) para Linux de 64 bits, o mesmo conjunto de ferramentas do playground e do curso de Assembly da Coddy. Começando agora em Assembly? O que é linguagem Assembly percorre um programa completo linha por linha, e o que é código de máquina mostra os bytes em que ele se transforma.
Todas as instruções desta página são montadas com nasm -f elf64. Experimente qualquer uma delas no playground de Assembly, que monta, linka e executa o seu programa no navegador sem instalar nada, ou aprenda passo a passo no curso gratuito de Assembly.
Perguntas frequentes sobre a folha de consulta de Assembly
Esta folha de consulta de Assembly é gratuita?
Sim. A folha de consulta inteira pode ser lida de graça, sem cadastro. Salve nos favoritos e volte quando precisar de um nome de registrador, uma instrução ou um número de chamada de sistema.
Qual Assembly esta folha de consulta cobre?
mov rax, rbx copia rbx para rax. A sintaxe AT&T, padrão do montador GNU, inverte a ordem e acrescenta prefixos, escrevendo movq %rbx, %rax. ARM64 e RISC-V têm instruções e registradores diferentes.Qual é a diferença entre mov e lea?
mov rax, [rsi + 8] lê os 8 bytes guardados no endereço rsi + 8. lea rax, [rsi + 8] só calcula o endereço e coloca o número em rax, sem tocar na memória. Como consegue somar e escalar registradores em um passo, lea também é usado como calculadora rápida, por exemplo lea rax, [rbx + rbx * 4] para multiplicar rbx por 5.Por que xor eax, eax é usado para zerar um registrador?
xor eax, eax tem 2 bytes, enquanto mov rax, 0 ocupa 5 ou mais. Escrever em um registrador de 32 bits como eax também zera a metade superior de rax, então o registrador de 64 bits inteiro vira 0. Os processadores reconhecem essa instrução e a tratam sem esperar pelo valor antigo.Para que servem os nomes de registradores de 64, 32, 16 e 8 bits?
rax são os 64 bits inteiros, eax os 32 inferiores, ax os 16 inferiores e al os 8 mais baixos. Eles permitem trabalhar com bytes e números menores; por exemplo, mov al, [rsi] lê um caractere de uma string. Escrever em eax zera os 32 bits superiores; escrever em ax ou al deixa o resto como está.Posso executar essas instruções online?
Sim. O playground de Assembly do Coddy monta x86-64 NASM, faz a linkagem e executa no Linux, depois mostra a saída e os erros. Você pode colar linhas desta folha de consulta em um programa e executá-lo no navegador.