Hai un eseguibile e vuoi capire cosa fa una sua funzione, senza i sorgenti. Oppure vuoi verificare cosa ha prodotto il compilatore da una riga di C, o sapere quali simboli contiene un file oggetto. objdump mostra il codice macchina in forma leggibile (assembly) e molto altro, senza eseguire il file.
Cos'è
objdump è uno strumento del pacchetto binutils (si installa con sudo apt install binutils, spesso già presente). Legge file oggetto, librerie ed eseguibili, in formato ELF su Linux, e ne mostra il contenuto. È il fratello maggiore di readelf: readelf descrive la struttura del file; objdump in più sa disassemblare, cioè tradurre i byte del codice nelle istruzioni del processore.
Cosa fa
Con objdump si può: leggere le istruzioni di una funzione, affiancare al codice macchina le righe di sorgente corrispondenti (se il binario ha le informazioni di debug), elencare le sezioni e i simboli, vedere le rilocazioni di un file oggetto e scaricare in esadecimale il contenuto di una sezione. Non esegue mai il programma.
Come si usa
$ objdump [opzioni] file...Senza opzioni non stampa nulla di utile: bisogna indicare cosa mostrare. Gli esempi usano un programma C di prova, h.c, con una funzione quadruplo e un main che la chiama, compilato su Ubuntu 24.04 per x86-64 (binutils 2.42). Gli output sono reali; ho tolto qualche riga vuota o di contorno, e dove serve lo scrivo. Nell'output originale i campi sono separati da tabulazioni: qui le ho sostituite con spazi.
Esempio 1: informazioni generali e sezioni
$ objdump -f h
h: file format elf64-x86-64
architecture: i386:x86-64, flags 0x00000150:
HAS_SYMS, DYNAMIC, D_PAGED
start address 0x0000000000001060
$ objdump -p h | grep NEEDED
NEEDED libc.so.6
$ objdump -h h | sed -n 4,6p | cut -c1-70
Sections:
Idx Name Size VMA LMA File off Algn
0 .interp 0000001c 0000000000000318 0000000000000318 00000318 2**0-f riassume il formato, l'architettura e l'indirizzo di partenza; -p mostra i "private headers", tra cui le librerie richieste (NEEDED); -h elenca le sezioni con dimensione e indirizzo (qui solo le prime righe). Sono informazioni che dà anche readelf, con un formato diverso.
Esempio 2: disassemblare una funzione
$ objdump -d --no-show-raw-insn --disassemble=quadruplo h
0000000000001149 <quadruplo>:
1149: endbr64
114d: push %rbp
114e: mov %rsp,%rbp
1151: mov %edi,-0x4(%rbp)
1154: mov -0x4(%rbp),%eax
1157: shl $0x2,%eax
115a: pop %rbp
115b: ret-d disassembla le sezioni con codice; --disassemble=nome limita l'output a una sola funzione (altrimenti escono centinaia di righe anche per un programma minuscolo). --no-show-raw-insn toglie la colonna con i byte esadecimali, per leggere meglio. Nell'output reale compaiono anche le intestazioni delle altre sezioni (.init, .plt...) e la sezione .fini, che ho omesso. Si riconosce l'argomento che arriva nel registro %edi e la moltiplicazione per 4, che il compilatore ha trasformato in uno scorrimento di 2 bit (shl $0x2). Questo è codice compilato senza ottimizzazioni (-O0): con ottimizzazioni sarebbe diverso.
Esempio 3: sintassi Intel e chiamate tra funzioni
$ objdump -d -M intel --no-show-raw-insn --disassemble=quadruplo h
1151: mov DWORD PTR [rbp-0x4],edi
1154: mov eax,DWORD PTR [rbp-0x4]
1157: shl eax,0x2
$ objdump -d --no-show-raw-insn --disassemble=main h | grep call
1169: call 1149 <quadruplo>
117f: call 1050 <printf@plt>Per default objdump usa la sintassi AT&T (mov origine,destinazione, registri con %). Con -M intel passa alla sintassi Intel, che molti trovano più leggibile (mov destinazione,origine). Il primo comando l'ho abbreviato alle tre righe centrali. Filtrare con grep call è un modo rapido per vedere quali funzioni ne chiamano altre: qui main chiama quadruplo e printf (tramite la tabella @plt, il meccanismo per le funzioni di libreria).
Esempio 4: affiancare il codice sorgente
$ objdump -d -S --no-show-raw-insn --disassemble=quadruplo h
0000000000001149 <quadruplo>:
#include <stdio.h>
int quadruplo(int x){return x*4;}
1149: endbr64
114d: push %rbp
114e: mov %rsp,%rbp
...-S intercala il sorgente alle istruzioni, ma funziona solo se il binario è stato compilato con -g e se il file sorgente è ancora disponibile nello stesso percorso. Nel mio test ha mostrato le righe del sorgente sopra l'inizio della funzione. Ho accorciato l'output con "...". Con ottimizzazioni attive la corrispondenza tra righe e istruzioni è meno lineare.
Esempio 5: simboli e binari "strippati"
$ objdump -t h | grep -E 'quadruplo|main'
0000000000001149 g F .text 0000000000000013 quadruplo
000000000000115c g F .text 000000000000002f main
$ objdump -t hs
hs: file format elf64-x86-64
SYMBOL TABLE:
no symbols-t stampa la tabella dei simboli: nome, indirizzo, dimensione e sezione (F indica una funzione). Il secondo comando è su una copia del programma a cui ho tolto i simboli con strip: la tabella è vuota e --disassemble=quadruplo non troverebbe nulla. Restano i simboli dinamici, cioè le funzioni importate dalle librerie, che si vedono con -T. Per i programmi C++ -C traduce i nomi "storpiati" dal compilatore: nel mio test _Z1fi diventa f(int).
Esempio 6: rilocazioni in un file oggetto
$ objdump -dr --no-show-raw-insn h.o | grep -E 'call|R_X86' | cut -c1-70
20: call 25 <main+0x12>
21: R_X86_64_PLT32 quadruplo-0x4
36: call 3b <main+0x28>
37: R_X86_64_PLT32 printf-0x4In un file .o non ancora collegato, gli indirizzi delle funzioni esterne non sono noti: dopo ogni call l'indirizzo è un segnaposto, e -r mostra le rilocazioni, cioè le istruzioni che il linker dovrà completare. Qui il compilatore ha lasciato da sistemare i riferimenti a quadruplo e printf.
Esempio 7: contenuto di una sezione in esadecimale
$ objdump -s -j .rodata h
h: file format elf64-x86-64
Contents of section .rodata:
2000 01000200 25640a00 ....%d..-s scarica il contenuto delle sezioni in esadecimale con a destra la versione testuale; -j sezione la limita a una sola. Nella sezione .rodata si ritrova la stringa di formato %d\n usata da printf. Lo stesso comando su .comment mostra il compilatore con cui è stato prodotto il binario.
Esempio 8: uso negli script
#!/bin/bash
# Mostra il disassemblato di una funzione di un binario (sintassi Intel)
[ $# -eq 2 ] || { echo "Uso: $0 binario funzione" >&2; exit 2; }
command -v objdump >/dev/null || { echo "objdump non trovato (binutils)" >&2; exit 3; }
[ -f "$1" ] || { echo "$1: file inesistente" >&2; exit 1; }
out=$(objdump -d -M intel --no-show-raw-insn --disassemble="$2" "$1" 2>/dev/null) \
|| { echo "$1: formato non riconosciuto" >&2; exit 1; }
echo "$out" | sed -n "/<$2>:/,/^\$/p" | grep -q . || {
echo "$2: funzione non trovata (binario senza simboli?)" >&2; exit 1; }
echo "$out" | sed -n "/<$2>:/,/^\$/p"Lo script prende un binario e il nome di una funzione e ne stampa il disassemblato in sintassi Intel, senza le sezioni circostanti. Esce con 0 se trova la funzione, 1 se il file non esiste, non è riconosciuto o la funzione non c'è, 2 con un numero di argomenti sbagliato e 3 se objdump manca. Si usa così: ./fn.sh h quadruplo. Nel mio test ha funzionato con la funzione presente, con la versione "strippata" del binario, con una funzione inesistente, con un file di testo e con un percorso inesistente. Il nome della funzione viene usato in un'espressione di sed: va bene per nomi semplici come quelli del C, non per nomi con caratteri speciali.
Opzioni utili
-d: disassembla le sezioni di codice.-Ddisassembla tutte le sezioni, anche i dati (utile per forzare, ma l'output ha poco senso sui dati).--disassemble=simbolo: solo la funzione indicata.-M intel: sintassi Intel invece di AT&T.--no-show-raw-insn: toglie i byte esadecimali accanto alle istruzioni.-S: affianca il sorgente (serve-gin compilazione).-t/-T: tabella dei simboli / dei soli simboli dinamici.-Cper i nomi C++.-h,-f,-p: sezioni, riepilogo del file, intestazioni private (librerie richieste).-r: mostra le rilocazioni (utile con-dsui file.o).-se-j sezione: contenuto delle sezioni in esadecimale, limitato a una.--start-address=INDIRIZZOe--stop-address=INDIRIZZO: disassembla solo un intervallo.
Attenzione a
- Il disassemblato dipende dal compilatore e dalle ottimizzazioni. Lo stesso C produce codice diverso con
-O0e-O2. Quello che si legge non è il sorgente originale, ma una sua traduzione. - Servono i simboli per trovare le funzioni per nome. Su un binario "strippato"
--disassemble=nomenon trova nulla: bisogna disassemblare per intervallo di indirizzi o partire dall'indirizzo di partenza (-f). - Disassemblare non è eseguire.
objdumpnon lancia il file, quindi si può usare anche su un binario sospetto. Non dice però cosa farà, e leggere assembly richiede esperienza. - L'output è lunghissimo. Anche un programma di 3 righe produce molte righe di disassemblato se si usa
-dsenza limitarlo. Meglio--disassemble=funzioneo un filtro congrep,sedehead. - È legato all'architettura. Il
objdumpdi sistema, per il suo processore, può non riconoscere binari di altre architetture (ad esempio ARM): non l'ho provato. - Dati scambiati per istruzioni. Con
-Do con intervalli sbagliati i dati vengono disassemblati come se fossero codice, e l'output sembra sensato ma non lo è.
Riepilogo
| Comando | Cosa fa |
|---|---|
objdump -f file | Mostra formato, architettura e indirizzo di partenza |
objdump -d --disassemble=f file | Disassembla la funzione f |
objdump -d -M intel file | Disassembla con sintassi Intel |
objdump -d -S file | Disassembla affiancando il sorgente (con -g) |
objdump -t file | Elenca i simboli |
objdump -T file | Elenca i simboli dinamici |
objdump -dr file.o | Disassembla mostrando le rilocazioni |
objdump -s -j .rodata file | Scarica una sezione in esadecimale |