Come rimuovere i simboli C / C ++ inutilizzati con GCC e ld?

Ho bisogno di ottimizzare la dimensione del mio eseguibile in modo serio ( ARMsviluppo) e ho notato che nel mio attuale schema di compilazione ( gcc+ ld) i simboli inutilizzati non vengono rimossi.

L'uso di arm-strip --strip-unneededper gli eseguibili / librerie risultanti non cambia la dimensione di output dell'eseguibile (non ho idea del perché, forse semplicemente non può) .

Quale sarebbe il modo (se esiste) per modificare la pipeline di costruzione, in modo che i simboli inutilizzati vengano rimossi dal file risultante?

Non ci penserei nemmeno, ma il mio attuale ambiente embedded non è molto "potente" e il risparmio anche 500Kdei 2Mrisultati in un bel miglioramento delle prestazioni di caricamento.

Aggiornare:

Sfortunatamente la gccversione corrente che uso non ha l' -dead-stripopzione e il -ffunction-sections... + --gc-sectionsfor ldnon dà alcuna differenza significativa per l'output risultante.

Sono scioccato dal fatto che questo sia diventato persino un problema, perché ero sicuro che gcc + ldavrebbe dovuto rimuovere automaticamente i simboli inutilizzati (perché devono anche tenerli?).

Per GCC, ciò si ottiene in due fasi:

Per prima cosa compila i dati ma chiedi al compilatore di separare il codice in sezioni separate all'interno dell'unità di traduzione. Questo verrà fatto per funzioni, classi e variabili esterne utilizzando i seguenti due flag del compilatore:

-fdata-sections -ffunction-sections

Collega le unità di traduzione insieme utilizzando il flag di ottimizzazione del linker (questo fa sì che il linker scarti le sezioni non referenziate):

-Wl,--gc-sections

Quindi, se avevi un file chiamato test.cpp che aveva due funzioni dichiarate in esso, ma una di esse era inutilizzata, potresti omettere quella inutilizzata con il seguente comando a gcc (g ++):

gcc -Os -fdata-sections -ffunction-sections test.cpp -o test -Wl,--gc-sections

(Nota che -Os è un flag aggiuntivo del compilatore che dice a GCC di ottimizzare per le dimensioni)

Se si vuole credere a questo thread , è necessario fornire -ffunction-sectionse-fdata-sections a gcc, che inserirà ogni funzione e oggetto dati nella propria sezione. Quindi date e --gc-sectionsa GNU ld per rimuovere le sezioni inutilizzate.

Ti consigliamo di controllare i tuoi documenti per la tua versione di gcc & ld:

Tuttavia per me (OS X gcc 4.0.1) li trovo per ld

-dead_strip

Rimuovere funzioni e dati che non sono raggiungibili dal punto di ingresso o dai simboli esportati.

-dead_strip_dylibs

Rimuovi i dylibs non raggiungibili dal punto di ingresso o dai simboli esportati. Cioè, sopprime la generazione di comandi di comando di caricamento per dylibs che non hanno fornito simboli durante il collegamento. Questa opzione non dovrebbe essere usata quando ci si collega a un dylib che è richiesto in fase di esecuzione per qualche motivo indiretto, come il dylib ha un inizializzatore importante.

E questa opzione utile

-why_live symbol_name

Registra una catena di riferimenti a symbol_name. Applicabile solo con -dead_strip. Può aiutare a eseguire il debug del motivo per cui qualcosa che pensi dovrebbe essere rimosso dalla striscia morta non viene rimosso.

C'è anche una nota in gcc / g ++ man che certi tipi di eliminazione di codice inattivo vengono eseguiti solo se l'ottimizzazione è abilitata durante la compilazione.

Sebbene queste opzioni / condizioni potrebbero non essere valide per il tuo compilatore, ti suggerisco di cercare qualcosa di simile nei tuoi documenti.

Anche le abitudini di programmazione potrebbero aiutare; es. aggiungi statica funzioni a cui non si accede al di fuori di un file specifico; usa nomi più brevi per i simboli (può aiutare un po ', probabilmente non troppo); utilizzare const char x[]dove possibile; ... questo documento , sebbene parli di oggetti dinamici condivisi, può contenere suggerimenti che, se seguiti, possono aiutare a ridurre la dimensione dell'output binario finale (se l'obiettivo è ELF).

La risposta è -flto. Devi passarlo sia alla fase di compilazione che a quella di collegamento, altrimenti non fa nulla.

In realtà funziona molto bene: ha ridotto le dimensioni di un programma di microcontrollore che ho scritto a meno del 50% delle dimensioni precedenti!

Sfortunatamente sembrava un po 'buggato - ho avuto casi di cose che non venivano costruite correttamente. Potrebbe essere stato dovuto al sistema di compilazione che sto utilizzando (QBS; è molto nuovo), ma in ogni caso ti consiglio di abilitarlo solo per la tua build finale, se possibile, e di testare a fondo quella build.

Anche se non strettamente sui simboli, se stai cercando la dimensione, compila sempre con -Ose -sflag. -Osottimizza il codice risultante per la dimensione minima eseguibile e -srimuove la tabella dei simboli e le informazioni di riposizionamento dall'eseguibile.

A volte, se si desidera una dimensione ridotta, giocare con diversi flag di ottimizzazione può o non può avere un significato. Ad esempio, la commutazione -ffast-mathe / o -fomit-frame-pointerpuò a volte farti risparmiare anche dozzine di byte.

Mi sembra che la risposta fornita da Nemo sia quella corretta. Se queste istruzioni non funzionano, il problema potrebbe essere correlato alla versione di gcc / ld che stai utilizzando, come esercizio ho compilato un programma di esempio utilizzando le istruzioni dettagliate qui

#include <stdio.h>
void deadcode() { printf("This is d dead codez\n"); }
int main(void) { printf("This is main\n"); return 0 ; }

Quindi ho compilato il codice utilizzando interruttori di rimozione del codice morto progressivamente più aggressivi:

gcc -Os test.c -o test.elf
gcc -Os -fdata-sections -ffunction-sections test.c -o test.elf -Wl,--gc-sections
gcc -Os -fdata-sections -ffunction-sections test.c -o test.elf -Wl,--gc-sections -Wl,--strip-all

Questi parametri di compilazione e collegamento hanno prodotto eseguibili di dimensione rispettivamente 8457, 8164 e 6160 byte, il contributo più sostanziale proveniente dalla dichiarazione "strip-all". Se non puoi produrre riduzioni simili sulla tua piattaforma, forse la tua versione di gcc non supporta questa funzionalità. Sto usando gcc (4.5.2-8ubuntu4), ld (2.21.0.20110327) su Linux Mint 2.6.38-8-generic x86_64

strip --strip-unneededopera solo sulla tabella dei simboli del tuo eseguibile. In realtà non rimuove alcun codice eseguibile.

Le librerie standard ottengono il risultato che cerchi suddividendo tutte le loro funzioni in file oggetto separati, che vengono combinati utilizzando ar. Se poi colleghi l'archivio risultante come una libreria (es. Dai l'opzione -l your_librarya ld) allora ld includerà solo i file oggetto, e quindi i simboli, che sono effettivamente usati.

Potresti anche trovare alcune delle risposte a questa domanda simile di utilizzo.

Non so se questo ti aiuterà con la tua situazione attuale poiché si tratta di una funzionalità recente, ma puoi specificare la visibilità dei simboli in modo globale. Passare -fvisibility=hidden -fvisibility-inlines-hiddenalla compilazione può aiutare il linker a sbarazzarsi successivamente dei simboli non necessari. Se stai producendo un eseguibile (al contrario di una libreria condivisa) non c'è più niente da fare.

Ulteriori informazioni (e un approccio a grana fine per es. Le librerie) sono disponibili sul wiki di GCC .

Dal manuale GCC 4.2.1, sezione -fwhole-program:

Si supponga che l'unità di compilazione corrente rappresenti l'intero programma in fase di compilazione. Tutte le funzioni e variabili pubbliche, ad eccezione di maine quelle unite per attributo, externally_visiblediventano funzioni statiche e in un affetto vengono ottimizzate in modo più aggressivo dagli ottimizzatori interprocedurali. Sebbene questa opzione sia equivalente all'uso corretto della staticparola chiave per programmi costituiti da un singolo file, in combinazione con l'opzione --combinequesto flag può essere utilizzato per compilare la maggior parte dei programmi C su scala ridotta poiché le funzioni e le variabili diventano locali per l'intera unità di compilazione combinata, non per il singolo file sorgente stesso.

Puoi usare lo strip binary sul file oggetto (es. Eseguibile) per rimuovere tutti i simboli da esso.

Nota: cambia il file stesso e non crea una copia.