Menu
CoddyTech

O que é a linguagem Assembly (linguagem de montagem)?

A linguagem Assembly, ou linguagem de montagem, é uma linguagem de programação de baixo nível em que as instruções de um processador são escritas uma por linha, com nomes curtos como mov e add em vez de números binários. Um programa chamado montador (assembler) a traduz para o código de máquina que a CPU executa.

Por Kevin Spektor, Cofundador e CTO

Atualizado em 16 de novembro de 2026

Este programa imprime uma linha. Clique em Executar: ele é montado com o NASM, linkado como um programa Linux e executado. Ele conversa diretamente com o Linux por meio de chamadas de sistema, sem a biblioteca C.

Hello from assembly!

Cada linha abaixo de _start é uma instrução para um processador x86-64, o tipo que está na maioria dos PCs com Windows e Linux. Não existe função print. O programa coloca quatro números nos registradores do processador e pede ao kernel do Linux que escreva os bytes.

Lendo o programa linha por linha

section .data inicia a parte do programa que guarda dados fixos. msg db "Hello from assembly!", 10 reserva bytes para o texto, e db significa "define bytes" (definir bytes). O 10 no final é o código de caractere da quebra de linha.

len equ $ - msg é calculado pelo montador, não pelo processador: $ é a posição atual, então a diferença é o tamanho da mensagem, 21 bytes.

section .text guarda as instruções. global _start torna o rótulo _start visível para o linker, que o marca como o ponto onde o programa começa.

mov rax, 1 copia o número 1 para o registrador rax. Um registrador é um pequeno espaço de armazenamento dentro do próprio processador, com 64 bits de largura no x86-64, e a maioria dos cálculos acontece em registradores. As três linhas mov seguintes preenchem rdi, rsi e rdx da mesma forma.

syscall passa o controle para o sistema operacional. O Linux olha rax para saber qual serviço foi pedido (1 é write) e rdi, rsi e rdx para os argumentos: onde escrever, o endereço dos bytes e quantos são. A segunda syscall, com 60 em rax, encerra o programa com o código de saída 0.

As palavras depois de ; são comentários. O montador os ignora, e em Assembly eles importam mais do que na maioria das linguagens, porque as instruções dizem o que acontece, mas não por quê.

Como o Assembly vira um programa

O processador não consegue ler o texto acima. Um montador o traduz para código de máquina, e um linker transforma isso em um arquivo que o sistema operacional pode executar:

  1. O montador (nasm -f elf64 hello.asm -o hello.o) traduz cada instrução para os seus bytes e grava um arquivo objeto.
  2. O linker (ld hello.o -o hello) preenche os endereços de memória finais, como onde msg vai ficar, e grava o executável.
  3. Executar ./hello faz o kernel carregar esses bytes na memória e iniciar o processador em _start.

Um desmontador (disassembler) mostra o que o montador produziu. Aqui está a saída de objdump -d -M intel hello.o, cortada nas três primeiras instruções:

0000000000000000 <_start>:
   0:   b8 01 00 00 00          mov    eax,0x1
   5:   bf 01 00 00 00          mov    edi,0x1
   a:   48 be 00 00 00 00 00    movabs rsi,0x0
  11:   00 00 00

Cada linha de Assembly virou uma instrução de 2 a 10 bytes. Dois detalhes mostram que o montador faz mais do que copiar: o NASM escolheu uma codificação mais curta para mov rax, 1, já que escrever em eax também zera a metade superior de rax, e o endereço de msg ainda é todo zeros, porque só o linker o conhece. A página de código de máquina lê esses bytes um por um.

Essa é a diferença em relação a um compilador. Um compilador parte de uma linguagem como C, em que uma linha pode virar muitas instruções, e escolhe essas instruções sozinho. Em Assembly, você escolhe cada instrução.

Os registradores fazem o trabalho

Assembly não tem variáveis declaradas com tipos, como Python ou C têm. Você decide onde cada valor fica: em um registrador enquanto o processador trabalha com ele, ou na memória, onde um rótulo como digit dá nome ao endereço. Este programa soma dois números e imprime o resultado:

7

A soma é o número 7, mas a tela mostra caracteres, então o programa soma 48, o código do caractere 0, antes de escrevê-lo. al é o byte mais baixo de rax, e [digit] com colchetes significa "a memória no endereço digit". Troque o 5 por 15 e a saída será A, o caractere de código 65: imprimir um número de dois dígitos exige um loop que divide por 10. Esse é o custo-benefício do Assembly em um só exemplo. Você controla cada passo, e precisa escrever cada passo.

Uma linguagem Assembly para cada família de processadores

Assembly não é uma linguagem só. Cada família de processadores tem as suas próprias instruções, registradores e regras, e o código escrito para uma não roda em outra. Aqui está a mesma operação, "colocar 1 no registrador do primeiro argumento", em três delas:

x86-64 (NASM):  mov rdi, 1
ARM64:          mov x0, #1
RISC-V:         li a0, 1
  • x86-64 roda na maioria dos PCs e servidores com Windows e Linux, em processadores Intel e AMD. As suas duas sintaxes colocam os operandos em ordem oposta: a sintaxe Intel escreve mov rax, 1, e a sintaxe AT&T, o padrão das ferramentas GNU, escreve movq $1, %rax.
  • ARM64, também chamado de AArch64, roda em quase todos os celulares, nos Macs com Apple silicon e em uma parcela crescente dos servidores na nuvem.
  • RISC-V é um conjunto de instruções aberto, comum em microcontroladores e no ensino.

Famílias mais antigas, como o 8086, o 6502 e o MIPS, ainda são ensinadas nas universidades porque são pequenas. As ideias valem para todas elas: registradores, endereços de memória, comparar e saltar.

Para que serve a linguagem Assembly

  • Sistemas operacionais. O código que inicia o processador, trata interrupções e alterna entre programas é escrito em parte em Assembly. O kernel do Linux o mantém em uma pasta separada para cada família de processadores.
  • Loops em que a velocidade é crítica. Decodificadores de vídeo como o dav1d e ferramentas de mídia como o FFmpeg usam Assembly escrito à mão nos poucos loops em que passam a maior parte do tempo.
  • Sistemas embarcados. Chips muito pequenos, com poucos kilobytes de memória, às vezes precisam de código em que cada byte é escolhido.
  • Ler o que um compilador gerou. O gcc -S e sites como o Compiler Explorer mostram o Assembly por trás de código C, C++ ou Rust, e é assim que as pessoas conferem otimizações.
  • Segurança e engenharia reversa. Um programa sem o seu código-fonte ainda pode ser desmontado, e é assim que analistas de malware e desenvolvedores de exploits o leem.
  • Aprender como os computadores funcionam. Um segmentation fault, um estouro de pilha ou um ponteiro fazem muito mais sentido depois de escrever as instruções por trás deles.

Mitos comuns sobre Assembly

  • "Assembly é código de máquina." É um texto que corresponde de perto ao código de máquina. Rótulos, comentários, db e equ existem só para o montador, e ele escolhe as codificações por você, como mostrou o mov rax, 1.
  • "Assembly é sempre mais rápido." O código é tão rápido quanto as instruções escolhidas, e os compiladores modernos escolhem muito bem. Assembly escrito à mão vence em casos restritos, geralmente loops que usam instruções especiais, e quem o escreve mede primeiro.
  • "Você precisa aprender Assembly antes de qualquer outra linguagem." Não precisa. É uma boa segunda ou terceira linguagem: depois que você sabe o que são uma variável e um loop, fica mais fácil ver como o processador os executa.

Próximos passos

Experimente alterar os programas acima no playground de Assembly, que roda o mesmo conjunto de ferramentas x86-64 NASM. A folha de consulta de Assembly lista os registradores, as instruções e as chamadas de sistema do Linux em uma página. Para ver em detalhes o que o montador produz, leia o que é código de máquina, e para praticar passo a passo registradores, memória, chamadas de sistema, aritmética e loops, faça o curso gratuito de Assembly.

Perguntas frequentes

A linguagem Assembly ainda é usada hoje?

Sim, mas em lugares pequenos e específicos. Os kernels de sistemas operacionais a usam no código que inicia o processador e alterna entre programas, o firmware de chips minúsculos a usa onde cada byte conta, e decodificadores de vídeo como o dav1d usam Assembly escrito à mão nos seus loops mais pesados. Muitos desenvolvedores que nunca escrevem Assembly ainda o leem, ao depurar uma falha, conferir o que um compilador gerou ou analisar malware.

Assembly é mais difícil que C++?
A linguagem em si é menor: algumas dezenas de instruções comuns, registradores e memória. Escrever um programa completo é mais difícil, porque você mesmo gerencia os registradores, a memória e o fluxo de controle. Não há tipos, nem comandos de loop, nem print, então uma única linha de C++ pode virar dez linhas de Assembly.
Qual é a diferença entre Assembly e um montador?
Assembly é a linguagem: o texto que você escreve, como mov rax, 1. Um montador (assembler) é o programa que traduz esse texto para código de máquina, como o NASM, o montador GNU as ou o MASM da Microsoft. Muita gente também chama a linguagem de "assembler", principalmente em alemão, russo e polonês, onde esse é o nome mais comum.
C++ é uma linguagem Assembly?
Não. C++ é uma linguagem de alto nível: um compilador a traduz, e uma linha pode virar muitas instruções de máquina, que o compilador consegue gerar para cada família de processadores que suporta. Assembly é ligado a uma família de processadores, e cada linha é uma instrução. Compiladores como o GCC podem mostrar o Assembly que geram para o seu código C++ com a flag -S.
Quantas linguagens Assembly existem?

Uma para cada família de processadores, além de sintaxes diferentes para algumas delas. As mais comuns hoje são x86-64, para PCs com Intel e AMD, ARM64, para celulares e Macs com Apple silicon, e RISC-V. Só para x86-64 existem duas sintaxes: Intel (usada pelo NASM e pelo MASM) e AT&T (o padrão do montador GNU).

Ilustração das linguagens de programação do Coddy

Aprenda a programar com o Coddy

Começar