Il linker si lamenta di un undefined reference to 'dbl'. Oppure vuoi sapere quale libreria definisce una certa funzione, o se un file oggetto usa una funzione che dovrebbe fornire qualcun altro. nm elenca i simboli di un file: è la risposta più rapida a "chi definisce cosa".
Cos'è
Quando si compila un programma, ogni funzione e ogni variabile globale riceve un nome, detto simbolo, che serve al linker per collegare i vari pezzi. nm legge quei nomi da file oggetto (.o), librerie (.a statiche, .so condivise) ed eseguibili, e li stampa uno per riga con il tipo e, se noto, l'indirizzo. Fa parte di binutils (sudo apt install binutils, spesso già presente).
Cosa fa
Per ogni simbolo nm mostra tre colonne: indirizzo (o valore), una lettera che indica il tipo e il nome. Le lettere più comuni sono:
T/t: funzione nella sezione del codice (text). Maiuscola = visibile dall'esterno (globale), minuscola = locale al file (staticin C).D/d: variabile con valore iniziale.B/b: variabile senza valore iniziale (bss).R/r: dato in sola lettura.U: simbolo non definito in questo file: lo deve fornire un altro file o una libreria.W/w: simbolo "debole" (weak), che può essere sostituito.
Come si usa
$ nm [opzioni] file...Gli esempi usano un piccolo file C, a.c, con una variabile inizializzata contatore, una non inizializzata vuoto, una variabile static segreto, una funzione globale quadruplo, una funzione static interna e un main che usa printf. Gli output sono reali, ottenuti su Ubuntu 24.04 (binutils 2.42); dove ho filtrato o accorciato lo dico.
Esempio 1: i simboli di un file oggetto
$ nm a.o
0000000000000000 D contatore
0000000000000013 t interna
000000000000002b T main
0000000000000000 D msg
U printf
0000000000000000 T quadruplo
0000000000000004 d segreto
0000000000000000 B vuotoQui si legge tutto il programma: le funzioni globali main e quadruplo sono T; interna, dichiarata static, è t minuscola (locale); contatore e il puntatore msg sono D; vuoto è B; segreto è d perché static. printf è U: il file la usa ma non la definisce, e il linker la cercherà nella libreria C. Gli indirizzi sono relativi alla sezione, non ancora definitivi.
Esempio 2: solo i simboli esterni e quelli mancanti
$ nm -g a.o
0000000000000000 D contatore
000000000000002b T main
0000000000000000 D msg
U printf
0000000000000000 T quadruplo
0000000000000000 B vuoto
$ nm -u a
w _ITM_deregisterTMCloneTable
w _ITM_registerTMCloneTable
w __cxa_finalize@GLIBC_2.2.5
w __gmon_start__
U __libc_start_main@GLIBC_2.34
U printf@GLIBC_2.2.5-g mostra solo i simboli globali (spariscono interna e segreto): è l'"interfaccia" del file. -u mostra solo quelli non definiti. Sull'eseguibile già collegato (a) sono le funzioni che il programma prende dalle librerie di sistema, con la versione di glibc richiesta dopo la @. È la domanda tipica davanti a un undefined reference: quale simbolo manca, e chi lo dovrebbe definire?
Esempio 3: dimensioni e ordinamento
$ nm -S -n a | grep -E 'quadruplo|main|contatore|vuoto'
0000000000001149 0000000000000013 T quadruplo
0000000000001174 0000000000000043 T main
0000000000004010 0000000000000004 D contatore
0000000000004024 0000000000000004 B vuoto
$ nm -S --size-sort a.o | tail -3
0000000000000000 0000000000000013 T quadruplo
0000000000000013 0000000000000018 t interna
000000000000002b 0000000000000043 T main-S aggiunge la dimensione in byte (in esadecimale), -n ordina per indirizzo, --size-sort per dimensione. Ho filtrato il primo comando con grep e preso le ultime tre righe del secondo. Per trovare le funzioni più "pesanti" di un binario si combina con tail. Il numero è esadecimale: 0x43 sono 67 byte.
Esempio 4: librerie condivise e binari "strippati"
$ nm -D /lib/x86_64-linux-gnu/libc.so.6 | grep -E ' T printf( |@)' | head -1
0000000000060100 T printf@@GLIBC_2.2.5
$ nm as
nm: as: no symbolsLe librerie condivise e gli eseguibili "strippati" (a cui è stata tolta la tabella dei simboli con strip) non mostrano nulla con nm semplice: bisogna usare -D per i simboli dinamici, quelli che servono al loader a runtime. L'indirizzo di printf è quello del mio sistema, e @@GLIBC_2.2.5 è la versione del simbolo. Il file as è una copia del programma a cui ho tolto i simboli: nm risponde "no symbols" e, nel mio test, esce comunque con codice 0.
Esempio 5: sorgente, file di origine e archivi
$ nm -l a | grep -E ' T (quadruplo|main)'
0000000000001174 T main /tmp/nm/a.c:8
0000000000001149 T quadruplo /tmp/nm/a.c:6
$ nm -A libmio.a | grep ' T '
libmio.a:m.o:0000000000000000 T dbl
libmio.a:a.o:000000000000002b T main
libmio.a:a.o:0000000000000000 T quadruplo-l aggiunge il file e la riga del sorgente in cui il simbolo è definito, ma solo se il binario è stato compilato con -g (nel mio test l'ho visto su a ma non su a.o, compilato senza). -A premette a ogni riga il nome del file, e per le librerie statiche (archivi .a) anche il membro: così si capisce quale .o dentro la libreria definisce cosa. La libreria libmio.a l'ho creata con ar per il test.
Esempio 6: nomi C++
$ nm c.o
0000000000000000 T _ZN1n1fEi
$ nm -C c.o
0000000000000000 T n::f(int)In C++ il compilatore codifica nome, namespace e tipi degli argomenti nel simbolo (mangling). -C (demangle) lo riporta a una forma leggibile: nel mio test _ZN1n1fEi diventa n::f(int).
Esempio 7: uso negli script
#!/bin/bash
# Dice quali file (oggetti, librerie, eseguibili) DEFINISCONO un simbolo
[ $# -ge 2 ] || { echo "Uso: $0 simbolo file..." >&2; exit 2; }
command -v nm >/dev/null || { echo "nm non trovato (binutils)" >&2; exit 3; }
sim=$1; shift
definisce() { # $1 = file; cerca nei simboli normali e in quelli dinamici
{ nm --defined-only "$1"; nm --defined-only -D "$1"; } 2>/dev/null |
awk -v s="$sim" '{ sub(/@.*/, "", $3) } $3 == s { ok = 1 } END { exit !ok }'
}
trovato=1
for f in "$@"; do
[ -f "$f" ] || { echo "$f: file inesistente" >&2; continue; }
if definisce "$f"; then
echo "$f: definisce $sim"; trovato=0
fi
done
exit $trovatoLo script cerca quali dei file indicati definiscono un simbolo, guardando sia i simboli normali sia quelli dinamici (--defined-only esclude i U) e togliendo il suffisso di versione dopo la @. Si usa ad esempio con ./sym.sh printf /lib/x86_64-linux-gnu/libc.so.6, oppure con ./sym.sh dbl lib/*.so lib/*.a per trovare chi fornisce una funzione. Esce con 0 se almeno un file definisce il simbolo, 1 se nessuno lo fa, 2 con argomenti insufficienti e 3 se nm manca. Nei miei test ha trovato quadruplo in un file oggetto, in un eseguibile e in un archivio .a (ma non nel file che non lo contiene), dbl in una libreria condivisa e printf nella libreria C. I file non riconosciuti (un file di testo, ad esempio) vengono saltati in silenzio.
Opzioni utili
-g: solo simboli globali (esterni).-u: solo simboli non definiti.--defined-only: solo quelli definiti.-D: simboli dinamici (per.soed eseguibili senza tabella dei simboli).-S: mostra la dimensione.-n: ordina per indirizzo.--size-sort: ordina per dimensione.-C: decodifica i nomi C++.-l: file e riga del sorgente (serve-gin compilazione).-A: prefissa a ogni riga il nome del file (e del membro, negli archivi).
Attenzione a
- Un file strippato non ha simboli.
nmrisponde "no symbols" e per le librerie condivise serve-D. Nel mio test il codice di uscita era comunque 0, quindi in uno script non basta controllarlo. - Le lettere hanno un significato preciso. Maiuscolo e minuscolo non sono equivalenti:
Tè globale etè locale. Una funzionestaticnon si può chiamare da altri file, quindi non la troverai tra leT. - Il nome non basta. Un simbolo definito in più librerie (versioni diverse, o in file diversi di un archivio) può dare conflitti.
nmmostra cosa c'è, non quale versione verrà scelta dal linker. - Le versioni compaiono con la
@. Nelle librerie condivise i simboli hanno un suffisso come@@GLIBC_2.2.5: chi cerca un nome congrep -wo con un confronto esatto può non trovarlo. Lo script dell'esempio 7 lo toglie. - I nomi C++ sono illeggibili senza
-C. Se cerchi una funzione C++ per nome, usa-Coppure cerca il nome "storpiato". - Altre architetture. Con binari di un'altra architettura (ad esempio ARM) non l'ho provato; il
nmdi sistema potrebbe non riconoscerli. - Non esegue il file. Come
readelfeobjdump, legge soltanto: è sicuro anche su un binario sospetto. Per un file non riconosciuto (ad esempio di testo) dà un errore e codice 1.
Riepilogo
| Comando | Cosa fa |
|---|---|
nm file.o | Elenca tutti i simboli con il loro tipo |
nm -g file | Solo i simboli globali |
nm -u file | Solo i simboli non definiti (da cercare altrove) |
nm -D libreria.so | Simboli dinamici di una libreria condivisa |
nm -S --size-sort file | Simboli ordinati per dimensione |
nm -C file | Nomi C++ in forma leggibile |
nm -A libreria.a | Simboli con file e membro dell'archivio |
nm -l file | Aggiunge file e riga del sorgente (con -g) |