aarch64-linux-gnu-gcov - Online nel cloud

PROGRAMMA:

NOME

gcov - strumento di test della copertura

SINOSSI

cov [-v|--versione] [-h|--Aiuto]
[-a|--tutti i blocchi]
[-b|--probabilità-diramazione]
[-c|--conta-rami]
[-d|--display-avanzamento]
[-f|--riassunti-funzione]
[-i|--formato-intermedio]
[-l|--nomi-file-lunghi]
[-m|--nomi-scomposti]
[-n|--nessuna uscita]
[-o|--directory-oggetto directory|file]
[-p|--preserve-percorsi]
[-r|--solo-relativo]
[-s|--prefisso-sorgente elenco]
[-u|--rami-incondizionati]
file

DESCRIZIONE

gcov è un programma di copertura di prova. Usalo insieme a GCC per analizzare i tuoi programmi per
aiuta a creare codice più efficiente e più veloce e a scoprire parti non testate del tuo
programma. Puoi usare gcov come strumento di profilazione per aiutarti a scoprire dove è la tua ottimizzazione
gli sforzi influenzeranno al meglio il tuo codice. Puoi anche usare gcov insieme all'altra profilazione
utensile, gprof, per valutare quali parti del codice utilizzano la maggior quantità di tempo di elaborazione.

Gli strumenti di profilazione ti aiutano ad analizzare le prestazioni del tuo codice. Utilizzando un profiler come gcov
or gprof, puoi trovare alcune statistiche di base sul rendimento, come:

* quanto spesso viene eseguita ogni riga di codice

* quali righe di codice vengono effettivamente eseguite

* quanto tempo di calcolo utilizza ogni sezione di codice

Una volta che conosci queste cose su come funziona il tuo codice quando viene compilato, puoi esaminarle ciascuna
module per vedere quali moduli dovrebbero essere ottimizzati. gcov ti aiuta a determinare dove lavorare
sull'ottimizzazione.

Gli sviluppatori di software utilizzano anche i test di copertura insieme alle suite di test, per essere sicuri
il software è in realtà abbastanza buono per un rilascio. Le suite di test possono verificare che un programma
funziona come previsto; un programma di copertura verifica quanto del programma viene esercitato da
la suite di prova. Gli sviluppatori possono quindi determinare a quali tipi di casi di test devono essere aggiunti
le suite di test per creare sia test migliori che un prodotto finale migliore.

Dovresti compilare il tuo codice senza ottimizzazione se prevedi di usarlo gcov poiché l'
l'ottimizzazione, combinando alcune righe di codice in un'unica funzione, potrebbe non darti tanto
informazioni di cui hai bisogno per cercare "punti caldi" in cui il codice utilizza una grande quantità di
tempo del computer. Allo stesso modo, perché gcov accumula statistiche per riga (al minimo
risoluzione), funziona meglio con uno stile di programmazione che inserisce solo un'istruzione su ciascuno
linea. Se utilizzi macro complicate che si espandono in loop o in altre strutture di controllo,
le statistiche sono meno utili --- riportano solo sulla linea in cui la macro chiama
appare. Se le tue macro complesse si comportano come funzioni, puoi sostituirle con inline
funzioni per risolvere questo problema.

gcov crea un file di registro chiamato file sorgente.gcov che indica quante volte ogni riga di
un file sorgente file sorgente.c ha eseguito. Puoi usare questi file di registro insieme a gprof a
aiuta a mettere a punto le prestazioni dei tuoi programmi. gprof ti dà informazioni sui tempi
può utilizzare insieme alle informazioni che ottieni da gcov.

gcov funziona solo su codice compilato con GCC. Non è compatibile con nessun'altra profilazione
o il meccanismo di copertura del test.

VERSIONI

-h
--Aiuto
Visualizza la guida sull'uso gcov (sull'output standard) ed esci senza fare nulla
ulteriore elaborazione.

-v
--versione
Mostra il gcov numero di versione (sullo standard output) ed esci senza fare nulla
ulteriore elaborazione.

-a
--tutti i blocchi
Scrivi conteggi di esecuzione individuali per ogni blocco di base. Normalmente output gcov
l'esecuzione conta solo per i blocchi principali di una riga. Con questa opzione puoi
determinare se i blocchi all'interno di una singola riga non vengono eseguiti.

-b
--probabilità-diramazione
Scrivi le frequenze del ramo nel file di output e scrivi le informazioni di riepilogo del ramo nel
uscita standard. Questa opzione ti permette di vedere con quale frequenza ogni ramo nel tuo programma
è stata scattata. I rami incondizionati non verranno mostrati, a meno che il -u l'opzione è data.

-c
--conta-rami
Scrivi le frequenze dei rami come il numero di rami presi, piuttosto che la percentuale
di rami presi.

-n
--nessuna uscita
Non creare il gcov file di uscita.

-l
--nomi-file-lunghi
Crea nomi di file lunghi per i file di origine inclusi. Ad esempio, se il file di intestazione xh
contiene codice ed è stato incluso nel file corrente alternata, poi correndo gcov sul file corrente alternata
produrrà un file di output chiamato ac##xhgcov invece di xhgcov. Questo può essere
utile se xh è incluso in più file sorgente e vuoi vedere l'individuo
contributi. Se usi il -p opzione, entrambi i nomi di file inclusi e inclusi
saranno nomi di percorso completi.

-p
--preserve-percorsi
Conserva le informazioni complete sul percorso nei nomi di generato .gcov File. Privo di
questa opzione, viene utilizzato solo il componente del nome del file. Con questa opzione, tutte le directory
sono usati, con / caratteri tradotti in # personaggi, . componenti della directory rimossi
e inamovibile .. componenti rinominati in ^. Questo è utile se i file sorgente sono in
diverse directory.

-r
--solo-relativo
Emetti solo informazioni sui file sorgente con un nome di percorso relativo (dopo source
prefisso elisione). I percorsi assoluti sono solitamente file di intestazione di sistema e copertura di qualsiasi
le funzioni inline al suo interno sono normalmente poco interessanti.

-f
--riassunti-funzione
Riepiloghi di output per ciascuna funzione oltre al riepilogo a livello di file.

-o directory|file
--directory-oggetto elenco
--file-oggetto filetto
Specificare la directory contenente i file di dati gcov o il nome del percorso dell'oggetto.
Il .gcnoe .gcda i file di dati vengono cercati utilizzando questa opzione. Se una directory è
specificato, i file di dati si trovano in quella directory e prendono il nome dal nome del file di input,
senza la sua estensione. Se viene specificato un file qui, i file di dati prendono il nome
quel file, senza la sua estensione.

-s elenco
--prefisso-sorgente elenco
Un prefisso per i nomi dei file di origine da rimuovere durante la generazione dei file di copertura dell'output.
Questa opzione è utile quando si compila in una directory separata e il percorso del
la directory di origine non è richiesta quando si determinano i nomi dei file di output. Nota che questo
il rilevamento del prefisso viene applicato prima di determinare se il file di origine è assoluto.

-u
--rami-incondizionati
Quando vengono fornite le probabilità dei rami, includere quelle dei rami incondizionati.
I rami incondizionati normalmente non sono interessanti.

-d
--display-avanzamento
Visualizza lo stato di avanzamento sullo standard output.

-i
--formato-intermedio
File gcov di output in un formato di testo intermedio facile da analizzare che può essere utilizzato da lcov
o altri strumenti. L'output è un singolo .gcov file per .gcda file. Nessun codice sorgente è
richiesto.

Il formato dell'intermedio .gcov il file è di testo semplice con una voce per riga

file:
funzione: , ,
conto: ,
ramo: ,

Dove il è
notexec (ramo non eseguito)
preso (ramo eseguito e preso)
nottaken (ramo eseguito, ma non preso)

Ci possono essere più voci in un gcov intermedio
file. Tutte le voci che seguono a riguardano quel file sorgente
fino al prossimo iscrizione.

Ecco un esempio di quando -i è usato insieme a -b opzione:

file:array.cc
funzione: 11,1,_Z3sumRKSt6vectorIPiSaIS0_EE
funzione: 22,1, principale
conto: 11,1
conto: 12,1
conto: 14,1
ramo: 14, preso
conto: 26,1
ramo: 28, non preso

-m
--nomi-scomposti
Visualizza i nomi delle funzioni smantellate nell'output. L'impostazione predefinita è mostrare la funzione alterata
nomi.

gcov dovrebbe essere eseguito con la directory corrente uguale a quella quando hai invocato il
compilatore. Altrimenti non sarà in grado di individuare i file di origine. gcov produce file
detto nomemangiato.gcov nella directory corrente. Questi contengono le informazioni sulla copertura
del file sorgente a cui corrispondono. Uno .gcov viene prodotto un file per ogni sorgente (o
header) file contenente il codice, che è stato compilato per produrre i file di dati. Il
nome storpiato parte del nome del file di output di solito è semplicemente il nome del file di origine, ma può
essere qualcosa di più complicato se il -l or -p le opzioni sono date. Fare riferimento a queste opzioni
per i dettagli.

Se invochi gcov con più file di input, i contributi di ciascun file di input sono
sommato. In genere lo invocheresti con lo stesso elenco di file del collegamento finale di
il tuo eseguibile.

Il .gcov i file contengono il : campi separati insieme al codice sorgente del programma. Il formato
is

: :

Ulteriori informazioni sul blocco possono succedere a ogni riga, se richieste dall'opzione della riga di comando.
Il conteggio_esecuzione is - per le righe che non contengono codice. Le righe non eseguite sono contrassegnate #####
or ====, a seconda che siano raggiungibili da percorsi non eccezionali o solo
percorsi eccezionali come i gestori di eccezioni C++, rispettivamente.

Alcune righe di informazioni all'inizio hanno numero_linea di zero. Queste righe di preambolo sono
del modulo

-:0: :

L'ordine e il numero di queste righe di preambolo saranno aumentati come gcov sviluppo
progredisce --- non fare affidamento sul fatto che rimangano invariati. Utilizzo etichetta per individuare un particolare
linea di preambolo.

Le informazioni aggiuntive sul blocco sono della forma



Il informazioni è leggibile dall'uomo, ma progettato per essere abbastanza semplice per l'analisi della macchina
troppo.

Quando si stampano percentuali, 0% e 100% vengono stampati solo quando i valori sono di preciso 0% e
100% rispettivamente. Altri valori che convenzionalmente verrebbero arrotondati allo 0% o al 100% sono
invece stampato come il valore non limite più vicino.

Quando si usa gcov, devi prima compilare il tuo programma con due speciali opzioni GCC:
-fprofile-archi -ftest-copertura. Questo dice al compilatore di generare ulteriori
informazioni necessarie a gcov (in pratica un diagramma di flusso del programma) e include anche
codice aggiuntivo nei file oggetto per generare le informazioni di profilatura aggiuntive necessarie
di gcov. Questi file aggiuntivi vengono inseriti nella directory in cui si trova il file oggetto
trova.

L'esecuzione del programma causerà la generazione dell'output del profilo. Per ogni file sorgente
compilato con -fprofile-archi, un accompagnamento .gcda il file verrà inserito nel file oggetto
directory.

corsa gcov con i nomi dei file sorgente del tuo programma come argomenti ora produrrà un elenco
del codice insieme alla frequenza di esecuzione per ogni riga. Ad esempio, se il tuo programma
è chiamato tmp.c, questo è quello che vedi quando usi il basic gcov servizio, struttura:

$ gcc -fprofile-archi -ftest-coverage tmp.c
$ un.out
$ gcov tmp.c
90.00% di 10 righe sorgente eseguite nel file tmp.c
Creazione di tmp.c.gcov.

Il file tmp.c.gcov contiene l'output di gcov. Ecco un esempio:

-: 0: Fonte: tmp.c
-: 0:Grafico:tmp.gcno
-: 0:Dati:tmp.gcda
-: 0:Corse:1
-: 0:Programmi:1
-: 1:#include
-: 2:
-: 3:int main (vuoto)
1:4:{
1: 5: int i, totale;
-: 6:
1: 7: totale = 0;
-: 8:
11: 9: per (i = 0; i < 10; i++)
10: 10: totale += i;
-: 11:
1: 12: if (totale != 45)
#####: 13: printf ("Errore\n");
-: 14: altro
1: 15: printf ("Successo\n");
1: 16: restituisce 0;
-: 17:}

Quando si utilizza il -a opzione, otterrai il conteggio dei singoli blocchi e l'output appare
come questo:

-: 0: Fonte: tmp.c
-: 0:Grafico:tmp.gcno
-: 0:Dati:tmp.gcda
-: 0:Corse:1
-: 0:Programmi:1
-: 1:#include
-: 2:
-: 3:int main (vuoto)
1:4:{
1: 4-blocco 0
1: 5: int i, totale;
-: 6:
1: 7: totale = 0;
-: 8:
11: 9: per (i = 0; i < 10; i++)
11: 9-blocco 0
10: 10: totale += i;
10: 10-blocco 0
-: 11:
1: 12: if (totale != 45)
1: 12-blocco 0
#####: 13: printf ("Errore\n");
$$$$$: 13 blocchi 0
-: 14: altro
1: 15: printf ("Successo\n");
1: 15-blocco 0
1: 16: restituisce 0;
1: 16-blocco 0
-: 17:}

In questa modalità, ogni blocco di base viene mostrato solo su una riga, l'ultima riga del blocco. UN
il blocco multilinea contribuirà solo al conteggio dell'esecuzione di quell'ultima riga e altro
le righe non verranno mostrate per contenere codice, a meno che i blocchi precedenti non finiscano su quelle righe. Il
viene mostrato il conteggio totale dell'esecuzione di una riga e le righe successive mostrano i conteggi dell'esecuzione
per i singoli blocchi che terminano su quella linea. Dopo ogni blocco, il derivato e la chiamata contano
del blocco verrà mostrato, se il -b l'opzione è data.

A causa del modo in cui gli strumenti GCC chiamano, è possibile visualizzare un conteggio delle chiamate dopo una riga senza n
singoli blocchi. Come puoi vedere, la riga 13 contiene un blocco di base che non è stato eseguito.

Quando si utilizza il -b opzione, il tuo output è simile a questo:

$ gcov -b tmp.c
90.00% di 10 righe sorgente eseguite nel file tmp.c
80.00% di 5 branch eseguiti nel file tmp.c
80.00% di 5 branch presi almeno una volta nel file tmp.c
50.00% di 2 chiamate eseguite nel file tmp.c
Creazione di tmp.c.gcov.

Ecco un esempio di un risultato tmp.c.gcov file:

-: 0: Fonte: tmp.c
-: 0:Grafico:tmp.gcno
-: 0:Dati:tmp.gcda
-: 0:Corse:1
-: 0:Programmi:1
-: 1:#include
-: 2:
-: 3:int main (vuoto)
funzione principale chiamata 1 ha restituito 1 blocchi eseguiti 75%
1:4:{
1: 5: int i, totale;
-: 6:
1: 7: totale = 0;
-: 8:
11: 9: per (i = 0; i < 10; i++)
ramo 0 preso 91% (fallthrough)
ramo 1 preso 9%
10: 10: totale += i;
-: 11:
1: 12: if (totale != 45)
ramo 0 preso 0% (fallthrough)
ramo 1 preso 100%
#####: 13: printf ("Errore\n");
chiamata 0 mai eseguita
-: 14: altro
1: 15: printf ("Successo\n");
chiama 0 chiamato 1 restituito 100%
1: 16: restituisce 0;
-: 17:}

Per ogni funzione viene stampata una riga che mostra quante volte la funzione viene chiamata, come
molte volte ritorna e quale percentuale dei blocchi della funzione è stata eseguita.

Per ogni blocco base, viene stampata una riga dopo l'ultima riga del blocco base che descrive
il derivato o la chiamata che termina il blocco base. Possono esserci più rami e chiamate
elencato per una singola riga di origine se sono presenti più blocchi di base che terminano su quella riga.
In questo caso, ai rami e alle chiamate viene assegnato un numero ciascuno. Non esiste un modo semplice per
mappare questi rami e richiamare i costrutti di origine. In generale, però, il più basso
il ramo o la chiamata numerati corrisponderanno al costrutto più a sinistra sulla riga di origine.

Per un ramo, se è stato eseguito almeno una volta, una percentuale che indica il numero di
volte che il branch è stato preso diviso per il numero di volte che il branch è stato eseguito sarà
stampato. In caso contrario viene stampato il messaggio "mai eseguito".

Per una chiamata, se è stata eseguita almeno una volta, una percentuale che indica il numero di
volte la chiamata restituita diviso per il numero di volte in cui la chiamata è stata eseguita sarà
stampato. Questo di solito sarà 100%, ma potrebbe essere inferiore per le funzioni che chiamano "exit" o
"longjmp", e quindi potrebbe non tornare ogni volta che vengono chiamati.

I conteggi delle esecuzioni sono cumulativi. Se il programma di esempio è stato eseguito di nuovo senza
rimuovendo il file .gcda file, il conteggio per il numero di volte in cui ogni riga nella sorgente è stata
eseguito verrebbe aggiunto ai risultati delle esecuzioni precedenti. Questo è potenzialmente utile
in diversi modi. Ad esempio, potrebbe essere utilizzato per accumulare dati su un numero di
il programma viene eseguito come parte di una suite di verifica dei test o per fornire risultati più accurati a lungo termine
informazioni su un gran numero di esecuzioni del programma.

I dati nel .gcda i file vengono salvati immediatamente prima della chiusura del programma. Per ciascuno
file sorgente compilato con -fprofile-archi, il codice di profilazione tenta prima di leggere in un
esistente .gcda file; se il file non corrisponde all'eseguibile (diverso numero di base
conteggi blocchi) ignorerà il contenuto del file. Quindi aggiunge nella nuova esecuzione
conta e infine scrive i dati nel file.

utilizzando gcov con GCC OTTIMIZZAZIONE

Se hai intenzione di usare gcov per aiutarti a ottimizzare il tuo codice, devi prima compilare il tuo programma
con due opzioni GCC speciali: -fprofile-archi -ftest-copertura. A parte questo, puoi
utilizzare qualsiasi altra opzione GCC; ma se vuoi dimostrare che ogni singola riga del tuo programma
è stato eseguito, non dovresti compilare con l'ottimizzazione allo stesso tempo. Su alcune macchine
l'ottimizzatore può eliminare alcune semplici righe di codice combinandole con altre righe.
Ad esempio, codice come questo:

se (a != b)
c = 1;
altro
c = 0;

può essere compilato in un'unica istruzione su alcune macchine. In questo caso, non c'è modo per
gcov per calcolare conteggi di esecuzione separati per ogni riga perché non c'è separato
codice per ogni riga. Quindi il gcov l'output è simile a questo se hai compilato il programma
con ottimizzazione:

100: 12: se (a != b)
100: 13: c = 1;
100: 14: altro
100: 15: c = 0;

L'output mostra che questo blocco di codice, combinato con l'ottimizzazione, è stato eseguito 100 volte.
In un certo senso questo risultato è corretto, perché c'era solo un'istruzione che rappresentava
tutte e quattro queste righe. Tuttavia, l'output non indica quante volte il risultato
era 0 e quante volte il risultato era 1.

Le funzioni inlineable possono creare conteggi di riga imprevisti. Vengono visualizzati i conteggi delle righe per
codice sorgente della funzione inlineable, ma ciò che viene mostrato dipende da dove si trova la funzione
inline o se non è affatto in linea.

Se la funzione non è inline, il compilatore deve emettere una copia fuori linea di
funzione, in qualsiasi file oggetto che ne abbia bisogno. Se fileA.o e fileB.o entrambi contengono fuori
corpi di linea di una particolare funzione inlineabile, conterranno entrambi anche la copertura
conta per quella funzione. quando fileA.o e fileB.o sono collegati tra loro, il linker,
su molti sistemi selezionare uno di quei corpi fuori linea per tutte le chiamate a quella funzione,
e rimuovere o ignorare l'altro. Sfortunatamente, non rimuoverà i contatori di copertura
per il corpo della funzione inutilizzata. Quindi, quando strumentati, tutti tranne un uso di quella funzione
mostrerà zero conteggi.

Se la funzione è inline in più punti, la struttura a blocchi in ogni posizione potrebbe
non essere lo stesso. Ad esempio, una condizione potrebbe ora essere calcolabile in fase di compilazione in
alcuni casi. Perché verrà mostrata la copertura di tutti gli usi della funzione in linea
per le stesse righe sorgente, il conteggio delle righe stesso potrebbe sembrare incoerente.

Le applicazioni di lunga durata possono utilizzare le funzionalità "_gcov_reset" e "_gcov_dump" per
limitare la raccolta del profilo alla regione di interesse del programma. Chiamata "_gcov_reset(void)"
azzera tutti i contatori del profilo e chiamando "_gcov_dump(void)" causerà il
informazioni sul profilo raccolte a quel punto per essere scaricate a .gcda file di output.

Usa aarch64-linux-gnu-gcov online usando i servizi onworks.net