Menu
CoddyTech

Cos'è il codice macchina?

Il codice macchina, chiamato anche linguaggio macchina, è l'insieme delle istruzioni binarie che un processore esegue direttamente. Ogni istruzione è una breve sequenza di byte, come b8 01 00 00 00, che dice alla CPU di spostare, sommare, confrontare o saltare, e ogni famiglia di processori ha il proprio set.

Di Kevin Spektor, Cofondatore e CTO

Aggiornato il 16 novembre 2026

Questo programma osserva tre delle sue stesse istruzioni, quelle sotto sample:, e stampa i byte che vede il processore. Premi Run:

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

Quei dodici byte sono il codice macchina delle tre righe sotto sample:, scritto in esadecimale, due cifre per byte. In memoria sono bit: b8 è 10111000. Il programma non li esegue mai. Li legge come leggerebbe qualsiasi altro dato, perché per il computer le istruzioni sono solo byte in memoria.

Leggere i byte

ByteAssemblyCosa fa il processore
b8 01 00 00 00mov rax, 1Mette il numero a 32 bit 1 in eax, il che azzera anche la metà alta di rax
bf 01 00 00 00mov rdi, 1La stessa cosa, in edi
0f 05syscallChiama il sistema operativo

Nelle prime due istruzioni il primo byte è l'opcode, la parte che dice cosa fare. Qui i byte da b8 a bf significano tutti "metti i prossimi 4 byte in un registro", e il registro dipende da quanto l'opcode dista da b8: eax è il registro 0, quindi il suo opcode è b8, e edi è il registro 7, quindi il suo opcode è b8 + 7, cioè bf. Non tutte le istruzioni x86-64 sono costruite in modo così semplice: alcune iniziano con un byte di prefisso, come il 48 davanti a molte istruzioni a 64 bit, e alcuni opcode occupano due byte, come 0f 05.

I 4 byte che seguono contengono il numero 1, ma al contrario: 01 00 00 00. x86-64 è little-endian, il che significa che un numero di più byte viene memorizzato a partire dal byte meno significativo. Il numero 258 sarebbe 02 01 00 00.

Anche l'assembler ha fatto una scelta qui. Il sorgente diceva mov rax, 1, un registro a 64 bit, ma NASM ha scritto l'istruzione da 5 byte per eax, perché scrivere in un registro a 32 bit mette a zero i 32 bit alti e il risultato è lo stesso. La forma lunga, 48 c7 c0 01 00 00 00, sarebbe di 7 byte.

Come il processore esegue il codice macchina

Il processore tiene l'indirizzo della prossima istruzione in un registro speciale, rip su x86-64, chiamato instruction pointer o program counter. Ripete tre passi miliardi di volte al secondo:

  1. Prelievo (fetch). Legge i byte all'indirizzo contenuto in rip.
  2. Decodifica (decode). Capisce di quale istruzione si tratta e quanto è lunga. Le istruzioni x86-64 sono lunghe da 1 a 15 byte, quindi il processore deve leggere i primi byte per sapere dove finisce l'istruzione. Le istruzioni ARM64 sono sempre di 4 byte.
  3. Esecuzione (execute). La esegue, poi sposta rip all'istruzione successiva, o a un altro indirizzo se l'istruzione era un salto.

Niente dice al processore se i byte in rip dovevano essere istruzioni. Se un bug lo manda a un indirizzo pieno di testo, decodifica quel testo come istruzioni e le esegue, oppure si ferma con un errore di istruzione non valida. I sistemi operativi moderni segnano la memoria dei dati come non eseguibile, quindi saltarci dentro termina invece il programma; su Linux questo viene segnalato come segmentation fault.

Codice macchina e linguaggio assembly a confronto

Il linguaggio assembly è la forma testuale del codice macchina. I due si corrispondono quasi uno a uno, ma non sono la stessa cosa:

Codice macchinaLinguaggio assembly
Che cos'èByte che il processore esegueTesto scritto da una persona
Esempiobf 01 00 00 00mov rdi, 1
Letto daIl processoreUn assembler, come NASM
Etichette e commentiNessuno, solo indirizzi_start:, ; comment
Dati nel sorgenteSemplicemente altri byteDirettive come db "Hello"
Legato a una famiglia di processoriSìSì

Un assembler va dalla colonna di destra a quella di sinistra. Un disassembler, come objdump -d, torna indietro: trasforma i byte in assembly. I commenti non vengono mai salvati nel codice macchina, quindi sono persi. I nomi delle etichette sopravvivono solo nella tabella dei simboli del file: sul programma qui sopra, objdump mostra il jnz del ciclo come jne 401019 <next_byte> (due nomi per la stessa istruzione), e dopo che strip ha rimosso i simboli, solo jne 0x401019. È così che si leggono i programmi di cui non si ha il codice sorgente.

Codice macchina e bytecode a confronto

Non tutti i programmi compilati sono codice macchina. Un compilatore per C, C++, Go o Rust produce codice macchina per un processore. Java compila in bytecode nei file .class, e Python compila il tuo codice in bytecode prima che il suo interprete lo esegua. Anche il bytecode ha istruzioni, ma sono per una macchina virtuale, cioè un programma, non per un chip fisico.

Per questo un file .class gira su qualsiasi computer con un ambiente di runtime Java, mentre un programma C compilato va ricompilato per ogni processore e sistema operativo. I due si incontrano nei compilatori just-in-time (JIT): la JVM e i motori JavaScript come V8 trasformano il bytecode più usato in codice macchina mentre il programma è in esecuzione.

Perché il codice macchina gira solo su un tipo di computer

Tre cose devono combaciare perché il codice macchina di un programma possa girare:

  • Il set di istruzioni. x86-64 e ARM64 usano byte diversi per operazioni diverse. Rosetta 2 di Apple permette ai Mac con Apple silicon di eseguire programmi x86-64 traducendo il loro codice macchina in codice macchina ARM64.
  • Il formato di file. Linux usa file ELF, Windows usa PE (.exe) e macOS usa Mach-O. Ognuno dice al sistema operativo dove si trovano codice e dati e da dove iniziare.
  • Le chiamate di sistema. L'esempio qui sopra chiede a Linux la chiamata di sistema 1, write. Windows e macOS numerano i loro servizi in modo diverso, quindi gli stessi byte chiederebbero qualcos'altro, o niente.

Dove andare dopo

Cambia le istruzioni sotto sample: nel playground Assembly ed esegui di nuovo il programma per vederne i byte: prova add rax, rbx o ret. La pagina sul linguaggio assembly spiega il linguaggio in cui sono scritte quelle istruzioni, la cheat sheet di Assembly elenca le istruzioni più comuni e il corso di Assembly gratuito insegna x86-64 a partire dalla prima chiamata di sistema. Per capire come bit e byte memorizzano tutto il resto, vedi la pagina sul byte.

Domande frequenti

Il codice macchina è fatto solo di 0 e 1?
Sì. In memoria ogni istruzione è una sequenza di bit, e i circuiti del processore reagiscono direttamente a quei bit. Però quasi nessuno lo scrive come 0 e 1: l'esadecimale è più corto e più facile da leggere, quindi l'istruzione 10111000 00000001 00000000 00000000 00000000 si scrive b8 01 00 00 00.
Qual è la differenza tra codice macchina e linguaggio assembly?
Il codice macchina sono i byte che il processore esegue. Il linguaggio assembly è una forma testuale delle stesse istruzioni, con nomi come mov al posto di numeri come b8, più etichette e commenti per le persone. Un assembler traduce l'assembly in codice macchina, e un disassembler lo ritraduce all'indietro, anche se etichette e commenti si perdono per strada.
Il codice macchina è uguale su tutti i computer?
No. Ogni famiglia di processori ha il proprio set di istruzioni: i byte 0f 05 significano syscall su x86-64, mentre un chip ARM64 legge le istruzioni 4 byte alla volta e non dà a quei byte lo stesso significato. Anche sullo stesso processore, Windows, macOS e Linux impacchettano i programmi in formati di file diversi e offrono chiamate di sistema diverse, quindi un programma viene compilato per un processore e un sistema operativo.
Qual è la differenza tra codice macchina e bytecode?
Il codice macchina gira su un processore fisico. Il bytecode è un insieme di istruzioni per una macchina virtuale, cioè un programma che legge ed esegue ogni istruzione. I file Java .class e i file Python .pyc contengono bytecode, che gira su qualsiasi computer dotato della macchina virtuale, e un compilatore JIT può trasformare le parti più usate in codice macchina mentre il programma è in esecuzione.
Le persone possono scrivere codice macchina?

Sì, e i primi programmatori lo facevano, inserendo i numeri a mano con interruttori o schede perforate. È lento e facile da sbagliare, perché ogni indirizzo va calcolato a mano, ed è per questo che i linguaggi assembly sono comparsi già alla fine degli anni Quaranta. Oggi le persone leggono il codice macchina in un debugger molto più spesso di quanto lo scrivano.

Illustrazione dei linguaggi di programmazione di Coddy

Impara a programmare con Coddy

Inizia