Menu
CoddyTech

O que é código de máquina?

Código de máquina, também chamado de linguagem de máquina, são as instruções binárias que um processador executa diretamente. Cada instrução é uma sequência curta de bytes, como b8 01 00 00 00, que diz à CPU para mover, somar, comparar ou saltar, e cada família de processadores tem o seu próprio conjunto.

Por Kevin Spektor, Cofundador e CTO

Atualizado em 16 de novembro de 2026

Este programa examina três das suas próprias instruções, as que estão abaixo de sample:, e imprime os bytes que o processador vê. Clique em Executar:

b8 01 00 00 00 bf 01 00 00 00 0f 05

Esses doze bytes são o código de máquina das três linhas abaixo de sample:, escritos em hexadecimal, dois dígitos por byte. Na memória eles são bits: b8 é 10111000. O programa nunca os executa. Ele os lê como leria qualquer outro dado, porque, para o computador, instruções são apenas bytes na memória.

Lendo os bytes

BytesAssemblyO que o processador faz
b8 01 00 00 00mov rax, 1Coloca o número de 32 bits 1 em eax, o que também zera a metade superior de rax
bf 01 00 00 00mov rdi, 1O mesmo, em edi
0f 05syscallChama o sistema operacional

Nas duas primeiras instruções, o primeiro byte é o opcode (código de operação), a parte que diz o que fazer. Aqui, de b8 a bf todos significam "coloque os próximos 4 bytes em um registrador", e o registrador é escolhido pela distância entre o opcode e b8: eax é o registrador 0, então o seu opcode é b8, e edi é o registrador 7, então o seu opcode é b8 + 7, ou seja, bf. Nem toda instrução x86-64 é construída de forma tão simples: algumas começam com um byte de prefixo, como o 48 na frente de muitas instruções de 64 bits, e alguns opcodes ocupam dois bytes, como 0f 05.

Os 4 bytes seguintes guardam o número 1, mas de trás para frente: 01 00 00 00. O x86-64 é little-endian, o que significa que um número de vários bytes é armazenado começando pelo byte mais baixo. O número 258 seria 02 01 00 00.

O montador também fez uma escolha aqui. O código-fonte dizia mov rax, 1, um registrador de 64 bits, mas o NASM gravou a instrução de 5 bytes para eax, porque escrever em um registrador de 32 bits zera os 32 bits superiores e o resultado é o mesmo. A forma longa, 48 c7 c0 01 00 00 00, teria 7 bytes.

Como o processador executa código de máquina

O processador guarda o endereço da próxima instrução em um registrador especial, rip no x86-64, chamado de ponteiro de instrução ou contador de programa. Ele repete três passos bilhões de vezes por segundo:

  1. Busca (fetch). Lê os bytes no endereço que está em rip.
  2. Decodificação. Descobre qual instrução eles formam e qual o tamanho dela. As instruções x86-64 têm de 1 a 15 bytes, então o processador precisa ler os primeiros bytes para saber onde a instrução termina. As instruções ARM64 têm sempre 4 bytes.
  3. Execução. Executa a instrução e depois move rip para a próxima, ou para outro endereço se a instrução era um salto.

Nada diz ao processador se os bytes em rip deveriam mesmo ser instruções. Se um bug o leva a um endereço cheio de texto, ele decodifica o texto como instruções e as executa, ou para com um erro de instrução ilegal. Os sistemas operacionais modernos marcam a memória de dados como não executável, então saltar para ela encerra o programa; no Linux, isso aparece como um segmentation fault.

Código de máquina vs linguagem Assembly

A linguagem Assembly é a forma em texto do código de máquina. Os dois se correspondem quase um para um, mas não são a mesma coisa:

Código de máquinaLinguagem Assembly
O que éBytes que o processador executaTexto que uma pessoa escreve
Exemplobf 01 00 00 00mov rdi, 1
Quem lêO processadorUm montador, como o NASM
Rótulos e comentáriosNenhum, só endereços_start:, ; comment
Dados no código-fonteApenas mais bytesDiretivas como db "Hello"
Ligado a uma família de processadoresSimSim

Um montador vai da coluna da direita para a da esquerda. Um desmontador, como o objdump -d, faz o caminho de volta: transforma bytes em Assembly. Comentários nunca são guardados no código de máquina, então se perdem. Os nomes dos rótulos sobrevivem apenas na tabela de símbolos do arquivo: no programa acima, o objdump mostra o jnz do loop como jne 401019 <next_byte> (dois nomes para a mesma instrução) e, depois que o strip remove os símbolos, apenas jne 0x401019. É assim que as pessoas leem programas dos quais não têm o código-fonte.

Código de máquina vs bytecode

Nem todo programa compilado é código de máquina. Um compilador de C, C++, Go ou Rust produz código de máquina para um processador. Java compila para bytecode em arquivos .class, e Python compila o seu código para bytecode antes que o interpretador o execute. O bytecode também tem instruções, mas elas são para uma máquina virtual, um programa, e não para um chip físico.

Por isso um mesmo arquivo .class roda em qualquer computador com um ambiente de execução Java, enquanto um programa C compilado precisa ser gerado de novo para cada processador e sistema operacional. Os dois se encontram nos compiladores just-in-time (JIT): a JVM e motores JavaScript como o V8 transformam o bytecode mais usado em código de máquina enquanto o programa roda.

Por que o código de máquina só roda em um tipo de computador

Três coisas precisam combinar para que o código de máquina de um programa possa rodar:

  • O conjunto de instruções. x86-64 e ARM64 usam bytes diferentes para operações diferentes. O Rosetta 2 da Apple permite que Macs com Apple silicon rodem programas x86-64 traduzindo o código de máquina deles para código de máquina ARM64.
  • O formato de arquivo. O Linux usa arquivos ELF, o Windows usa PE (.exe) e o macOS usa Mach-O. Cada um diz ao sistema operacional onde estão o código e os dados e por onde começar.
  • As chamadas de sistema. O exemplo acima pede ao Linux a chamada de sistema 1, write. Windows e macOS numeram os seus serviços de outro jeito, então os mesmos bytes pediriam outra coisa, ou nada.

Próximos passos

Altere as instruções abaixo de sample: no playground de Assembly e execute o programa de novo para ver os bytes delas: experimente add rax, rbx ou ret. A página da linguagem Assembly explica a linguagem em que essas instruções são escritas, a folha de consulta de Assembly lista as instruções mais comuns, e o curso gratuito de Assembly ensina x86-64 desde a primeira chamada de sistema. Para ver como bits e bytes guardam todo o resto, veja a página do byte.

Perguntas frequentes

Código de máquina é só 0 e 1?
Sim. Na memória, toda instrução é um padrão de bits, e os circuitos do processador reagem diretamente a esses bits. Mesmo assim, quase ninguém o escreve com 0 e 1: o hexadecimal é mais curto e mais fácil de ler, então a instrução 10111000 00000001 00000000 00000000 00000000 é escrita como b8 01 00 00 00.
Qual é a diferença entre código de máquina e linguagem Assembly?
Código de máquina são os bytes que o processador executa. A linguagem Assembly é uma forma em texto das mesmas instruções, com nomes como mov em vez de números como b8, além de rótulos e comentários para as pessoas. Um montador traduz Assembly para código de máquina, e um desmontador faz o caminho inverso, embora os rótulos e comentários se percam no caminho.
O código de máquina é igual em todo computador?
Não. Cada família de processadores tem o seu próprio conjunto de instruções: os bytes 0f 05 significam syscall no x86-64, enquanto um chip ARM64 lê as instruções de 4 em 4 bytes e não dá esse significado a esses bytes. Mesmo no mesmo processador, Windows, macOS e Linux empacotam os programas em formatos de arquivo diferentes e oferecem chamadas de sistema diferentes, então um programa é gerado para um processador e um sistema operacional.
Qual é a diferença entre código de máquina e bytecode?
O código de máquina roda em um processador físico. Bytecode é um conjunto de instruções para uma máquina virtual, um programa que lê e executa cada instrução. Os arquivos .class do Java e .pyc do Python guardam bytecode, que roda em qualquer computador que tenha a máquina virtual, e um compilador JIT pode transformar as partes mais usadas em código de máquina enquanto o programa roda.
Pessoas conseguem escrever código de máquina?

Sim, e os primeiros programadores faziam isso, digitando números à mão com chaves ou cartões perfurados. É lento e fácil de errar, porque cada endereço precisa ser calculado à mão, e foi por isso que as linguagens Assembly surgiram já no fim dos anos 1940. Hoje as pessoas leem código de máquina em um depurador com muito mais frequência do que o escrevem.

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

Aprenda a programar com o Coddy

Começar