Salta al contenuto principale

strip: alleggerire un binario togliendo simboli e debug

Inviato da tuxsa il

Compili un programma e scopri che l'eseguibile pesa più del previsto: dentro ci sono nomi di funzioni e variabili e, se hai compilato con -g, anche le informazioni di debug. Sono utili a chi sviluppa, ma inutili per far girare il programma. strip li toglie.

Cos'è

strip è un programma del pacchetto binutils (sudo apt install binutils, spesso già presente) che rimuove dai file oggetto, dalle librerie e dagli eseguibili i simboli e le sezioni di debug. È il comando con cui si preparano i binari da distribuire: stesso programma, meno peso, meno informazioni interne esposte.

Cosa fa

Di default strip riscrive il file indicato, togliendo la tabella dei simboli e le informazioni di debug. Il codice e i dati restano identici, quindi il programma funziona come prima. Gli strumenti che dipendono dai simboli, come nm e objdump con il nome delle funzioni, o un debugger, non trovano più nulla da mostrare. Funziona anche su librerie condivise e file oggetto, ma con alcune conseguenze, descritte più sotto.

Come si usa

$ strip [opzioni] file...

Gli esempi usano un programma C di prova, a.c, compilato con gcc -g su Ubuntu 24.04 (binutils 2.42). Gli output sono reali. Le dimensioni in byte dipendono da compilatore e opzioni: contano le proporzioni, non i numeri assoluti. Il programma è minuscolo, quindi il risparmio in valore assoluto è piccolo; su programmi grandi con molti simboli e debug è molto più marcato.

Esempio 1: togliere tutto da un eseguibile

$ cp a b
$ strip b
$ ls -l a b | awk '{print $5, $9}'
17480 a
14480 b
$ ./b
32
$ nm b
nm: b: no symbols
$ file a b | grep -o -E 'with debug_info|not stripped|, stripped'
with debug_info
not stripped
, stripped

Ho lavorato su una copia (b) per non perdere l'originale: strip modifica il file in loco. Il file è passato da 17480 a 14480 byte, il programma gira ancora (stampa 32) e nm non vede più simboli. Il comando file distingue i due casi: not stripped (anche con with debug_info) oppure stripped. Il comando file stampa altro oltre a quanto ho filtrato.

Esempio 2: scrivere il risultato su un altro file

$ strip -o d a
$ ls -l a d | awk '{print $5, $9}'
17480 a
14480 d

Con -o file l'originale resta intatto e il risultato va nel file indicato: è la forma più sicura, soprattutto negli script. Il risultato è identico a quello dell'esempio 1.

Esempio 3: togliere solo le informazioni di debug

$ cp a c
$ strip -g c
$ ls -l c | awk '{print $5}'
15920
$ nm c | grep -c quadruplo
1
$ readelf -S -W c | grep -c debug
0

-g (strip debug) toglie solo le sezioni di debug, e lascia la tabella dei simboli. Il file è sceso da 17480 a 15920 byte (contro i 14480 della rimozione totale), nm trova ancora quadruplo e nessuna sezione di debug è rimasta. È una via di mezzo utile quando si vogliono ancora vedere i nomi delle funzioni, ad esempio nelle tracce di errore.

Esempio 4: file oggetto, simboli locali e simboli da tenere

$ cp a.o e.o
$ strip --strip-unneeded e.o
$ nm e.o
0000000000000000 D contatore
000000000000002b T main
                 U printf
0000000000000018 T quadruplo

$ cp a f
$ strip -K quadruplo f
$ nm f
0000000000001161 T quadruplo
$ ./f
32

--strip-unneeded toglie i simboli non necessari alla rilocazione: nel file oggetto è sparito interna (una funzione static, quindi locale), ma restano quelli globali e printf, che il linker deve ancora risolvere. Con -K nome (keep symbol) si toglie tutto tranne il simbolo indicato: nell'eseguibile f è rimasto solo quadruplo e il programma funziona.

Esempio 5: tenere i simboli di debug in un file separato

$ cp a k
$ objcopy --only-keep-debug k k.debug
$ strip k
$ objcopy --add-gnu-debuglink=k.debug k
$ ls -l k k.debug | awk '{print $5, $9}'
14576 k
6112 k.debug
$ ./k
32

È la procedura classica per distribuire un binario leggero senza perdere la possibilità di fare debug: objcopy --only-keep-debug estrae le informazioni di debug in k.debug, strip alleggerisce il binario e --add-gnu-debuglink vi aggiunge un riferimento al file di debug. Un debugger come gdb può poi usare k.debug per ritrovare nomi e righe di sorgente. Nel mio test ho verificato la creazione dei file e che il programma funzioni; non ho provato gdb. Il binario k è un po' più grande di b (14576 contro 14480) perché contiene il riferimento al file di debug.

Esempio 6: uso negli script

#!/bin/bash
# Crea copie "strippate" dei binari indicati in una cartella e mostra il risparmio
[ $# -ge 2 ] || { echo "Uso: $0 cartella_destinazione file..." >&2; exit 2; }
command -v strip >/dev/null || { echo "strip non trovato (binutils)" >&2; exit 3; }
dest=$1; shift
mkdir -p "$dest" || exit 1
rc=0
for f in "$@"; do
    [ -f "$f" ] || { echo "$f: file inesistente" >&2; rc=1; continue; }
    out="$dest/$(basename "$f")"
    if ! strip -o "$out" "$f" 2>/dev/null; then
        echo "$f: non strippabile (non e' un binario?)" >&2; rc=1; continue
    fi
    prima=$(stat -c %s "$f"); dopo=$(stat -c %s "$out")
    echo "$f: $prima -> $dopo byte (-$((prima - dopo)))"
done
exit $rc

Lo script non tocca mai gli originali: per ogni file crea una copia strippata nella cartella indicata e stampa dimensione prima e dopo. Esce con 0 se tutto va bene, 1 se qualche file manca o non è strippabile (un file di testo, ad esempio), 2 con argomenti insufficienti e 3 se strip non c'è. Nei miei test, su un eseguibile e un file oggetto ha stampato 17480 -> 14480 byte (-3000) e 4360 -> 1112 byte (-3248); con un file di testo e un percorso inesistente ha segnalato l'errore e l'originale è rimasto invariato. Attenzione: se due file in input hanno lo stesso nome (in cartelle diverse), la seconda copia sovrascrive la prima.

Opzioni utili

  • -o file: scrive il risultato in un altro file e lascia intatto l'originale.
  • -g (o -S): toglie solo le informazioni di debug.
  • --strip-unneeded: toglie i simboli non necessari alla rilocazione (pensato per file oggetto e librerie).
  • -K nome / -N nome: tiene / toglie un singolo simbolo.
  • -R sezione: rimuove una sezione intera. Nel mio test su .comment la sezione risultava poi non più presente.
  • -v: mostra cosa viene fatto. -p: conserva data e ora del file.

Attenzione a

  • Cambia il file in loco. Senza -o l'originale viene sovrascritto e i simboli persi. Conserva una copia non strippata, o almeno il file di debug dell'esempio 5, perché le tracce di crash e i debugger ne hanno bisogno.
  • Non su un file oggetto che deve ancora essere collegato. Con un semplice strip su un .o perdi i simboli di cui il linker ha bisogno: nel mio test il successivo gcc sul file strippato ha dato errori di collegamento. Per i .o e le librerie statiche si usa al massimo -g o --strip-unneeded.
  • Non su un programma in esecuzione. Su un eseguibile avviato, strip in loco ha dato Text file busy e codice 1. Fermare il programma, oppure scrivere su un altro file con -o e sostituirlo.
  • Le librerie condivise mantengono i simboli dinamici. Nel test su una .so, dopo strip nm non mostrava più nulla, ma nm -D vedeva ancora la funzione esportata: servono al loader per collegare i programmi e non vengono tolti.
  • Non è una protezione. Togliere i simboli rende il binario più difficile da leggere, non impossibile da analizzare. Il codice resta e si può ancora disassemblare.
  • Serve il formato giusto. Su un file non binario (testo, script) dà errore e codice 1. Le versioni di strip per altre architetture non le ho provate.
  • Verifica dopo averlo usato. Controlla che il programma parta ancora (come nell'esempio 1) prima di distribuire.

Riepilogo

ComandoCosa fa
strip fileToglie simboli e debug, riscrivendo il file
strip -o nuovo fileCome sopra, ma scrive su un altro file
strip -g fileToglie solo le informazioni di debug
strip --strip-unneeded file.oToglie i simboli locali non necessari
strip -K nome fileTiene solo il simbolo indicato
objcopy --only-keep-debug f f.debugEstrae il debug in un file separato
file binarioDice se è stripped o not stripped