Assembly Cheat Sheet
Ultimo aggiornamento
Struttura del programma
Un programma senza la libreria C parte dall'etichetta indicata al linker, di solito _start.
| Elemento | Codice |
|---|---|
| Sezione per i dati fissi | section .data |
| Sezione per i buffer azzerati | section .bss |
| Sezione per le istruzioni | section .text |
| Rendere visibile al linker il punto di ingresso | global _start |
| Un'etichetta (un indirizzo con nome) | _start: |
| Commento | ; everything after a semicolon |
| Terminare il programma con codice di uscita 0 | mov rax, 60 → mov rdi, 0 → syscall |
Registri
Sedici registri generali a 64 bit. Ognuno ha nomi più brevi per i suoi 32, 16 e 8 bit più bassi.
| Registro e uso comune | Nomi a 64 / 32 / 16 / 8 bit |
|---|---|
| Accumulatore, numero della chiamata di sistema, valore di ritorno | rax eax ax al |
| Base, conservato tra le chiamate di funzione | rbx ebx bx bl |
| Contatore, 4° argomento di funzione | rcx ecx cx cl |
Dati, 3° argomento, metà alta di mul e div | rdx edx dx dl |
| Indice sorgente, 2° argomento | rsi esi si sil |
| Indice destinazione, 1° argomento | rdi edi di dil |
| Stack pointer, cima dello stack | rsp esp sp spl |
| Base pointer, stack frame | rbp ebp bp bpl |
Registri extra, mostrati per r8; da r9 a r15 seguono lo stesso schema | r8 r8d r8w r8b |
| Instruction pointer, indirizzo della prossima istruzione | rip |
Flag impostati da cmp, test e dall'aritmetica | rflags |
Direttive dei dati
Le direttive le legge l'assembler e riservano o danno un nome alla memoria; non sono istruzioni.
| Significato | Codice |
|---|---|
| Definire byte: una stringa e un a capo | msg db "Hello", 10 |
| Definire una word a 16 bit | year dw 2026 |
| Definire una doubleword a 32 bit | count dd 1000 |
| Definire una quadword a 64 bit | big dq 123456789 |
Riservare 64 byte azzerati (in .bss) | buffer resb 64 |
| Riservare 10 quadword | table resq 10 |
| Dare un nome a una costante | max equ 100 |
| Lunghezza dei dati appena sopra | len equ $ - msg |
| Ripetere una definizione | zeros times 8 db 0 |
Spostare dati
La destinazione viene per prima. Le parentesi quadre indicano la memoria a quell'indirizzo.
| Operazione | Codice |
|---|---|
| Un numero in un registro | mov rax, 42 |
| Un registro in un registro | mov rbx, rax |
| L'indirizzo di un'etichetta in un registro | mov rsi, msg |
| Leggere 8 byte dalla memoria | mov rax, [big] |
| Scrivere un registro in memoria | mov [big], rax |
| Scrivere un byte, con la dimensione esplicita | mov byte [buffer], 10 |
| Leggere la memoria a registro più offset | mov al, [rsi + 1] |
| Indicizzato: base + indice * scala + offset | mov rax, [table + rcx * 8] |
| Calcolare un indirizzo senza leggere la memoria | lea rax, [rsi + rcx * 2] |
| Caricare un byte e azzerare il resto del registro | movzx eax, byte [rsi] |
| Scambiare due registri | xchg rax, rbx |
Aritmetica e logica
Le istruzioni a due operandi scrivono il risultato nel primo operando. mul, div e idiv usano anche rax e rdx per conto proprio. L'effetto sui flag varia: not lascia i flag invariati, mentre div e idiv li lasciano indefiniti.
| Operazione | Codice |
|---|---|
| Somma | add rax, rbx |
| Sottrazione | sub rax, 5 |
| Aggiungere 1 / togliere 1 | inc rcx / dec rcx |
| Moltiplicazione con segno in un registro | imul rax, rbx |
Moltiplicazione senza segno: rdx:rax = rax * rbx | mul rbx |
Divisione senza segno del valore in rax per rbx: azzera prima rdx; quoziente in rax, resto in rdx | xor rdx, rdx → div rbx |
Divisione con segno: prima estendere il segno di rax in rdx | cqo → idiv rbx |
| Cambio di segno | neg rax |
| And, or, xor, not bit a bit | and rax, 0xff / or rax, rbx / xor rax, rbx / not rax |
| Azzerare un registro (breve e veloce) | xor eax, eax |
| Shift a sinistra (moltiplica per 2 per ogni bit) | shl rax, 3 |
| Shift a destra: senza segno / con segno | shr rax, 1 / sar rax, 1 |
Confronti e salti
cmp sottrae senza salvare il risultato e imposta i flag; poi un salto condizionato li legge.
| Operazione | Codice |
|---|---|
| Confrontare due valori | cmp rax, rbx |
| Controllare dei bit (and senza salvare), spesso per verificare lo zero | test rax, rax |
| Saltare sempre | jmp done |
| Saltare se uguale / zero | je done / jz done |
| Saltare se diverso / non zero | jne loop_start / jnz loop_start |
| Con segno: maggiore, maggiore o uguale, minore, minore o uguale | jg / jge / jl / jle |
| Senza segno: sopra (above), sopra o uguale, sotto (below), sotto o uguale | ja / jae / jb / jbe |
| Ciclo di 10 ripetizioni con un contatore | mov rcx, 10 → again: → dec rcx → jnz again |
| Copiare solo se la condizione vale (senza salto) | cmovg rax, rbx |
Stack e funzioni
Lo stack cresce verso il basso: push abbassa rsp di 8, pop lo alza.
| Operazione | Codice |
|---|---|
| Mettere un registro sullo stack / riprenderlo | push rbx / pop rbx |
| Chiamare una funzione (salva sullo stack l'indirizzo di ritorno) | call print_line |
| Tornare al chiamante | ret |
| Riservare 32 byte di spazio locale | sub rsp, 32 |
| Liberarlo | add rsp, 32 |
| Creare uno stack frame | push rbp → mov rbp, rsp |
| Smontarlo | mov rsp, rbp → pop rbp |
| Argomenti, in ordine (System V, Linux e macOS) | rdi rsi rdx rcx r8 r9 |
Registri che una funzione deve ripristinare prima di ret | rbx rbp r12 r13 r14 r15 |
Chiamate di sistema Linux
Metti il numero in rax e gli argomenti in rdi, rsi, rdx, r10, r8, r9, poi esegui syscall. Il risultato torna in rax; un valore negativo è un codice di errore.
| Chiamata | Registri |
|---|---|
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 |
| Standard input, output, error | fd 0 fd 1 fd 2 |
| Registri sovrascritti dal kernel | rcx r11 |
Assemblare, eseguire e ispezionare
Su una macchina Linux con NASM e gli strumenti GNU installati.
| Attività | Comando |
|---|---|
| Assemblare in un file oggetto | nasm -f elf64 main.asm -o main.o |
| Collegare in un programma | ld main.o -o main |
| Eseguirlo e mostrare il codice di uscita | ./main; echo $? |
| Disassemblare, sintassi Intel | objdump -d -M intel main |
| Eseguirlo passo passo in un debugger | gdb ./main |
| Vedere l'assembly scritto da un compilatore C | gcc -S -O2 -masm=intel file.c |
I registri, le istruzioni e le chiamate di sistema che usi più spesso quando scrivi assembly x86-64, in una sola pagina. Ogni riga è in sintassi NASM (ordine degli operandi Intel, destinazione per prima) per Linux a 64 bit, la stessa toolchain del playground e del corso di Assembly di Coddy. Sei alle prime armi con l'assembly? Cos'è il linguaggio assembly analizza un programma completo riga per riga, e cos'è il codice macchina mostra i byte in cui si trasforma.
Ogni istruzione qui si assembla con nasm -f elf64. Provale nel playground Assembly, che assembla, collega ed esegue il tuo programma nel browser senza installare nulla, oppure imparale passo dopo passo nel corso di Assembly gratuito.
Domande frequenti sulla cheat sheet di assembly
Questa cheat sheet di assembly è gratuita?
Sì. Tutta la cheat sheet è gratuita da consultare, senza registrazione. Salvala nei preferiti e torna quando ti serve il nome di un registro, un'istruzione o il numero di una chiamata di sistema.
Quale assembly copre questa cheat sheet?
mov rax, rbx copia rbx in rax. La sintassi AT&T, quella predefinita dell'assembler GNU, inverte l'ordine e aggiunge dei prefissi, scrivendo movq %rbx, %rax. ARM64 e RISC-V hanno istruzioni e registri diversi.Qual è la differenza tra mov e lea?
mov rax, [rsi + 8] legge gli 8 byte memorizzati all'indirizzo rsi + 8. lea rax, [rsi + 8] calcola solo l'indirizzo e mette il numero in rax, senza toccare la memoria. Poiché può sommare e scalare registri in un solo passo, lea si usa anche come calcolatrice veloce, per esempio lea rax, [rbx + rbx * 4] per moltiplicare rbx per 5.Perché si usa xor eax, eax per azzerare un registro?
xor eax, eax è lunga 2 byte, mentre mov rax, 0 ne richiede 5 o più. Scrivere in un registro a 32 bit come eax azzera anche la metà alta di rax, quindi l'intero registro a 64 bit diventa 0. I processori riconoscono questa istruzione e la gestiscono senza aspettare il vecchio valore.A cosa servono i nomi dei registri a 64, 32, 16 e 8 bit?
rax sono tutti i 64 bit, eax i 32 più bassi, ax i 16 più bassi e al gli 8 più bassi. Ti permettono di lavorare con byte e numeri più piccoli, per esempio mov al, [rsi] legge un carattere di una stringa. Scrivere in eax azzera i 32 bit alti; scrivere in ax o al lascia invariato il resto.Posso eseguire queste istruzioni online?
Sì. Il playground Assembly di Coddy assembla x86-64 NASM, lo collega e lo esegue su Linux, poi mostra l'output ed eventuali errori. Puoi incollare righe di questa cheat sheet in un programma ed eseguirlo nel browser.