Menu
CoddyTech

Cos'è il linguaggio assembly?

Il linguaggio assembly è un linguaggio di programmazione a basso livello in cui le istruzioni di un processore si scrivono una per riga, con nomi brevi come mov e add invece che con numeri binari. Un programma chiamato assembler lo traduce nel codice macchina che la CPU esegue.

Di Kevin Spektor, Cofondatore e CTO

Aggiornato il 16 novembre 2026

Questo programma stampa una riga. Premi Run: viene assemblato con NASM, collegato in un programma Linux ed eseguito. Parla direttamente con Linux tramite le chiamate di sistema, senza la libreria C.

Hello from assembly!

Ogni riga sotto _start è un'istruzione per un processore x86-64, quello della maggior parte dei PC Windows e Linux. Non esiste una funzione print. Il programma mette quattro numeri nei registri del processore e chiede al kernel Linux di scrivere i byte.

Il programma riga per riga

section .data apre la parte del programma che contiene i dati fissi. msg db "Hello from assembly!", 10 riserva i byte per il testo, e db significa "define bytes", cioè definisci dei byte. Il 10 alla fine è il codice del carattere di a capo.

len equ $ - msg viene calcolato dall'assembler, non dal processore: $ è la posizione corrente, quindi la differenza è la lunghezza del messaggio, 21 byte.

section .text contiene le istruzioni. global _start rende l'etichetta _start visibile al linker, che la segna come il punto in cui il programma inizia.

mov rax, 1 copia il numero 1 nel registro rax. Un registro è un piccolo spazio di memoria dentro il processore stesso, largo 64 bit su x86-64, e la maggior parte dei calcoli avviene nei registri. Le tre righe mov successive riempiono allo stesso modo rdi, rsi e rdx.

syscall passa il controllo al sistema operativo. Linux guarda rax per capire quale servizio viene richiesto (1 è write) e rdi, rsi e rdx per i suoi argomenti: dove scrivere, l'indirizzo dei byte e quanti sono. La seconda syscall, con 60 in rax, termina il programma con codice di uscita 0.

Le parole dopo ; sono commenti. L'assembler li ignora, e in assembly contano più che nella maggior parte dei linguaggi, perché le istruzioni dicono cosa succede ma non perché.

Come l'assembly diventa un programma

Il processore non sa leggere il testo qui sopra. Un assembler lo traduce in codice macchina, e un linker lo trasforma in un file che il sistema operativo può eseguire:

  1. L'assembler (nasm -f elf64 hello.asm -o hello.o) traduce ogni istruzione nei suoi byte e scrive un file oggetto.
  2. Il linker (ld hello.o -o hello) inserisce gli indirizzi di memoria definitivi, come quello in cui si troverà msg, e scrive l'eseguibile.
  3. Avviare ./hello fa caricare al kernel quei byte in memoria e fa partire il processore da _start.

Un disassembler mostra cosa ha prodotto l'assembler. Ecco objdump -d -M intel hello.o, tagliato alle prime tre istruzioni:

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

Ogni riga di assembly è diventata un'istruzione da 2 a 10 byte. Due dettagli mostrano che l'assembler fa più che copiare: NASM ha scelto una codifica più corta per mov rax, 1, dato che scrivere in eax azzera anche la metà alta di rax, e l'indirizzo di msg è ancora tutto a zero perché solo il linker lo conosce. La pagina sul codice macchina legge questi byte uno per uno.

Questa è la differenza rispetto a un compilatore. Un compilatore parte da un linguaggio come il C, in cui una riga può diventare molte istruzioni, e sceglie da solo quelle istruzioni. In assembly, ogni istruzione la scegli tu.

I registri fanno il lavoro

L'assembly non ha variabili dichiarate con un tipo, come in Python o in C. Sei tu a decidere dove sta ogni valore: in un registro mentre il processore ci lavora, oppure in memoria, dove un'etichetta come digit dà un nome all'indirizzo. Questo programma somma due numeri e stampa il risultato:

7

La somma è il numero 7, ma lo schermo mostra caratteri, quindi il programma aggiunge 48, il codice del carattere 0, prima di scriverlo. al è il byte più basso di rax, e [digit] tra parentesi quadre significa "la memoria all'indirizzo digit". Cambia il 5 in 15 e l'output diventa A, il carattere con codice 65: per stampare un numero di due cifre serve un ciclo che divide per 10. Ecco il compromesso dell'assembly in un solo esempio. Controlli ogni passo, e ogni passo lo devi scrivere tu.

Un linguaggio assembly per ogni famiglia di processori

L'assembly non è un unico linguaggio. Ogni famiglia di processori ha istruzioni, registri e regole proprie, e il codice scritto per una non funziona su un'altra. Ecco la stessa operazione, "metti 1 nel primo registro degli argomenti", in tre di esse:

x86-64 (NASM):  mov rdi, 1
ARM64:          mov x0, #1
RISC-V:         li a0, 1
  • x86-64 fa girare la maggior parte dei PC e dei server Windows e Linux, su processori Intel e AMD. Le sue due sintassi mettono gli operandi in ordine opposto: la sintassi Intel scrive mov rax, 1, e la sintassi AT&T, quella predefinita degli strumenti GNU, scrive movq $1, %rax.
  • ARM64, chiamato anche AArch64, fa girare quasi tutti gli smartphone, i Mac con Apple silicon e una quota crescente dei server cloud.
  • RISC-V è un set di istruzioni aperto, diffuso nei microcontrollori e nella didattica.

Famiglie più vecchie come l'8086, il 6502 e MIPS si studiano ancora all'università perché sono piccole. Le idee si trasferiscono da una all'altra: registri, indirizzi di memoria, confronto e salto.

A cosa serve il linguaggio assembly

  • Sistemi operativi. Il codice che avvia il processore, gestisce gli interrupt e passa da un programma all'altro è scritto in parte in assembly. Il kernel Linux lo tiene in una cartella separata per ogni famiglia di processori.
  • Cicli in cui la velocità è critica. I decoder video come dav1d e gli strumenti multimediali come FFmpeg usano assembly scritto a mano per i pochi cicli in cui passano la maggior parte del tempo.
  • Sistemi embedded. I chip molto piccoli, con pochi kilobyte di memoria, a volte hanno bisogno di codice in cui ogni byte è scelto con cura.
  • Leggere cosa ha prodotto un compilatore. gcc -S e siti come Compiler Explorer mostrano l'assembly dietro al codice C, C++ o Rust, ed è così che si controllano le ottimizzazioni.
  • Sicurezza e reverse engineering. Un programma senza il suo codice sorgente si può comunque disassemblare, ed è così che lo leggono gli analisti di malware e chi sviluppa exploit.
  • Capire come funzionano i computer. Un segmentation fault, uno stack overflow o un puntatore hanno molto più senso dopo aver scritto le istruzioni che ci sono dietro.

Miti comuni sull'assembly

  • "L'assembly è codice macchina." È testo che corrisponde molto da vicino al codice macchina. Etichette, commenti, db e equ esistono solo per l'assembler, che sceglie le codifiche al posto tuo, come ha mostrato mov rax, 1.
  • "L'assembly è sempre più veloce." Il codice è veloce solo quanto le istruzioni scelte, e i compilatori moderni scelgono molto bene. L'assembly scritto a mano vince in casi ristretti, di solito cicli che usano istruzioni speciali, e chi lo scrive misura prima di tutto.
  • "Serve l'assembly prima di qualsiasi altro linguaggio." Non serve. È un buon secondo o terzo linguaggio: una volta che sai cosa sono una variabile e un ciclo, è più facile vedere come il processore li esegue.

Dove andare dopo

Prova a modificare i programmi qui sopra nel playground Assembly, che usa la stessa toolchain x86-64 NASM. La cheat sheet di Assembly raccoglie registri, istruzioni e chiamate di sistema Linux in una sola pagina. Per vedere nel dettaglio cosa produce l'assembler, leggi cos'è il codice macchina, e per esercitarti passo dopo passo con registri, memoria, chiamate di sistema, aritmetica e cicli segui il corso di Assembly gratuito.

Domande frequenti

Il linguaggio assembly si usa ancora oggi?

Sì, ma in punti piccoli e specifici. I kernel dei sistemi operativi lo usano per il codice che avvia il processore e passa da un programma all'altro, il firmware dei chip minuscoli lo usa dove ogni byte conta, e i decoder video come dav1d usano assembly scritto a mano per i loro cicli più intensi. Molti sviluppatori che non lo scrivono mai lo leggono comunque, quando fanno il debug di un crash, controllano cosa ha prodotto un compilatore o analizzano un malware.

L'assembly è più difficile del C++?
Il linguaggio in sé è più piccolo: qualche decina di istruzioni comuni, i registri e la memoria. Scrivere un programma completo è più difficile, perché registri, memoria e flusso di controllo li gestisci tu. Non ci sono tipi, istruzioni di ciclo o print, quindi una sola riga di C++ può richiedere dieci righe di assembly.
Qual è la differenza tra linguaggio assembly e assembler?
L'assembly è il linguaggio: il testo che scrivi, per esempio mov rax, 1. Un assembler è il programma che traduce quel testo in codice macchina, come NASM, l'assembler GNU as o MASM di Microsoft. Spesso si dice "assembler" anche per indicare il linguaggio, soprattutto in tedesco, russo e polacco, dove è il nome abituale.
Il C++ è un linguaggio assembly?
No. Il C++ è un linguaggio ad alto livello: lo traduce un compilatore, e una riga può diventare molte istruzioni macchina, che il compilatore sa produrre per ogni famiglia di processori che supporta. L'assembly è legato a una famiglia di processori, e ogni riga è un'istruzione. Compilatori come GCC possono mostrarti l'assembly che generano per il tuo codice C++ con l'opzione -S.
Quanti linguaggi assembly esistono?

Uno per ogni famiglia di processori, più sintassi diverse per alcune di esse. I più comuni oggi sono x86-64 per i PC Intel e AMD, ARM64 per gli smartphone e i Mac con Apple silicon, e RISC-V. Solo per x86-64 esistono due sintassi, Intel (usata da NASM e MASM) e AT&T (quella predefinita dell'assembler GNU).

Illustrazione dei linguaggi di programmazione di Coddy

Impara a programmare con Coddy

Inizia