Opzioni della riga di comando GCC non comuni ma utili

Gli strumenti software offrono solitamente molteplici funzionalità, ma - come molti di voi saranno d’accordo - non tutte le loro funzionalità sono utilizzate da tutti. In generale, non c’è nulla di sbagliato in questo, poiché ogni utente ha le proprie esigenze e utilizza gli strumenti solo all’interno di quella sfera. Tuttavia, è sempre bene continuare a esplorare gli strumenti che si utilizzano, poiché non si sa mai quando una delle loro funzionalità potrebbe tornare utile, risparmiando così un po’ del proprio prezioso tempo nel processo.

Un caso in questione: i compilatori. Un buon compilatore di linguaggio di programmazione offre sempre una miriade di opzioni, ma gli utenti generalmente conoscono e utilizzano solo un insieme limitato. Specificamente, se sei uno sviluppatore del linguaggio C e utilizzi Linux come piattaforma di sviluppo, è molto probabile che tu stia usando il compilatore gcc, che offre un elenco infinito di opzioni della riga di comando.

Sai che se vuoi, puoi chiedere a gcc di salvare l’output in ogni fase del processo di compilazione? Sai che l’opzione -Wall che usi per generare avvisi non copre alcuni avvisi specifici? Ci sono molte opzioni della riga di comando gcc che non sono comunemente utilizzate, ma possono essere estremamente utili in determinati scenari, ad esempio, durante il debug del codice.

Quindi, in questo articolo, copriremo un paio di tali opzioni, offrendo tutti i dettagli richiesti e spiegandole attraverso esempi facili da comprendere, ove necessario.

Ma prima di procedere, ti preghiamo di tenere a mente che tutti gli esempi, i comandi e le istruzioni menzionati in questo tutorial sono stati testati su Ubuntu 16.04 LTS, e la versione di gcc che abbiamo utilizzato è 5.4.0.

Vedi l’output intermedio durante ogni fase di compilazione

Sai che ci sono, in linea di massima, un totale di quattro fasi che il tuo codice C attraversa quando lo compili utilizzando il compilatore gcc? Queste sono la preelaborazione, la compilazione, l’assemblaggio e il collegamento. Dopo ogni fase, gcc produce un file di output temporaneo che viene passato alla fase successiva. Ora, questi sono tutti file temporanei che vengono prodotti, e quindi non possiamo vederli - tutto ciò che vediamo è che abbiamo emesso il comando di compilazione e produce il binario/eseguibile che possiamo eseguire.

Ma supponiamo che, mentre fai debug, ci sia la necessità di vedere come appariva il codice dopo, diciamo, la fase di preelaborazione. Allora, cosa faresti? Bene, la cosa buona è che il compilatore gcc offre un’opzione della riga di comando che puoi utilizzare nel tuo comando di compilazione standard e otterrai quei file intermedi che altrimenti verrebbero eliminati dal compilatore. L’opzione di cui stiamo parlando è -save-temps.

Ecco cosa dice la pagina man di gcc riguardo a questa opzione:

           Memorizza i soliti file "temporanei" intermedi in modo permanente; posizionali  
           nella directory corrente e chiamali in base al file sorgente.  
           Così, compilando foo.c con -c -save-temps produce file  
           foo.i e foo.s, oltre a foo.o.  
           Questo crea un file di output foo.i preelaborato anche se il  
           compilatore ora normalmente utilizza un preelaboratore integrato.  
           
           Quando usato in combinazione con l'opzione della riga di comando -x,  
           -save-temps è abbastanza sensato da evitare di sovrascrivere un file  
           sorgente di input con la stessa estensione di un file intermedio.  
           Il file intermedio corrispondente può essere ottenuto rinominando il  
           file sorgente prima di utilizzare -save-temps.

Di seguito è riportato un comando di esempio che ti darà un’idea su come puoi utilizzare questa opzione:

gcc -Wall -save-temps test.c -o test-exec

E questo è come ho verificato che tutti i file intermedi sono stati effettivamente prodotti dopo che il comando sopra menzionato è stato eseguito:

Quindi, come puoi vedere nello screenshot sopra, i file test.i, test.s e test.o sono stati prodotti dall’opzione -save-temps. Questi file corrispondono alle fasi di preelaborazione, compilazione e collegamento, rispettivamente.

Rendi il tuo codice pronto per il debug e il profiling

Ci sono strumenti dedicati che ti permettono di fare debug e profiling del tuo codice sorgente. Ad esempio, gdb è utilizzato per scopi di debug, mentre gprof è uno strumento popolare per scopi di profiling. Ma sai che ci sono opzioni specifiche della riga di comando che gcc offre per rendere il tuo codice pronto sia per il debug che per il profiling?

Iniziamo con il debug. Per poter utilizzare gdb per il debug del codice, dovrai compilare il tuo codice utilizzando l’opzione della riga di comando -g fornita dal compilatore gcc. Questa opzione consente fondamentalmente a gcc di produrre informazioni di debug necessarie a gdb per eseguire correttamente il debug del tuo programma.

Nel caso tu abbia intenzione di utilizzare questa opzione, ti consigliamo di consultare i dettagli che la pagina man di gcc offre su questa opzione - alcuni di questi possono rivelarsi vitali in alcuni casi. Ad esempio, di seguito è riportato un estratto preso dalla pagina man:

           GCC ti consente di utilizzare -g con -O.  Le scorciatoie adottate dal codice  
           ottimizzato possono occasionalmente produrre risultati sorprendenti: alcune variabili  
           che hai dichiarato potrebbero non esistere affatto; il flusso di controllo potrebbe  
           spostarsi brevemente dove non ti aspettavi; alcune istruzioni potrebbero non  
           essere eseguite perché calcolano risultati costanti o i loro valori sono già  
           a disposizione; alcune istruzioni potrebbero essere eseguite in luoghi diversi  
           perché sono state spostate fuori dai cicli.  
           
           Tuttavia, è possibile eseguire il debug dell'output ottimizzato.  
           Questo rende ragionevole utilizzare l'ottimizzatore per programmi che potrebbero  
           avere bug.

Non solo gdb, compilare il tuo codice utilizzando l’opzione -g apre anche la possibilità di utilizzare il tool memcheck di Valgrind al suo completo potenziale. Per coloro che non lo sanno, memcheck è utilizzato dai programmatori per controllare eventuali perdite di memoria nel loro codice. Puoi saperne di più su questo strumento qui.

Passando oltre, per poter utilizzare gprof per il profiling del codice, devi compilare il tuo codice utilizzando l’opzione della riga di comando -pg. Essa consente a gcc di generare codice extra per scrivere informazioni di profiling, necessarie a gprof per l’analisi del codice. “Devi utilizzare questa opzione quando compili i file sorgente di cui vuoi dati, e devi utilizzarla anche durante il collegamento,” dice la pagina man di gcc. Per saperne di più su come eseguire il profiling del codice utilizzando gprof, vai a questo tutorial dedicato sul nostro sito web.

Nota: L’uso delle opzioni -g e -pg è simile al modo in cui è stata utilizzata l’opzione -save-temps nella sezione precedente.

Conclusione

A meno che tu non sia un esperto di gcc, sono sicuro che hai imparato qualcosa di nuovo con questo articolo. Prova queste opzioni e vedi come funzionano. Nel frattempo, aspetta la prossima parte di questa serie di tutorial in cui discuteremo altre opzioni della riga di comando gcc interessanti e utili.