mips64-linux-gnuabi64-gcov-5 - Online în cloud

PROGRAM:

NUME

gcov - instrument de testare a acoperirii

REZUMAT

gcov [-v|--versiune] [-h|--Ajutor]
[-a|--toate blocurile]
[-b|--ramură-probabilităţi]
[-c|--ramură-numărătoare]
[-d|--afișare-progres]
[-f|--rezumate-funcții]
[-i|--format-intermediar]
[-l|--long-file-names]
[-m|--nume-descurcat]
[-n|--fără-ieșire]
[-o|--director-obiect director|fișier]
[-p|--conserva-cărări]
[-r|--numai-rudă]
[-s|--source-prefix director]
[-u|--ramuri-neconditionate]
fișiere

DESCRIERE

gcov este un program de testare. Utilizați-l împreună cu GCC pentru a vă analiza programele
ajutați la crearea unui cod mai eficient și mai rapid și pentru a descoperi părți netestate ale dvs
program. Poți să folosești gcov ca instrument de profilare pentru a vă ajuta să descoperiți unde optimizați dvs
eforturile vor afecta cel mai bine codul dvs. De asemenea, puteți utiliza gcov împreună cu celelalte profilări
instrument, gprof, pentru a evalua ce părți ale codului dvs. folosesc cea mai mare cantitate de timp de calcul.

Instrumentele de profilare vă ajută să analizați performanța codului dvs. Folosind un profiler, cum ar fi gcov
or gprof, puteți afla câteva statistici de bază de performanță, cum ar fi:

* cât de des se execută fiecare linie de cod

* ce linii de cod sunt de fapt executate

* cât timp de calcul folosește fiecare secțiune de cod

Odată ce știți aceste lucruri despre modul în care funcționează codul dvs. atunci când este compilat, puteți să vă uitați la fiecare
modul pentru a vedea ce module trebuie optimizate. gcov vă ajută să determinați unde să lucrați
pe optimizare.

Dezvoltatorii de software folosesc, de asemenea, testarea acoperirii împreună cu testele, pentru a se asigura
software-ul este de fapt suficient de bun pentru o lansare. Testsuites pot verifica că un program
funcționează conform așteptărilor; un program de acoperire testează pentru a vedea cât de mult din program este exercitat de
suita de teste. Dezvoltatorii pot determina apoi la ce tipuri de cazuri de testare trebuie adăugate
testele pentru a crea atât teste mai bune, cât și un produs final mai bun.

Ar trebui să compilați codul fără optimizare dacă intenționați să îl utilizați gcov deoarece volumul
optimizarea, prin combinarea unor linii de cod într-o singură funcție, poate să nu vă ofere atât de mult
informații, deoarece trebuie să căutați „puncte fierbinți” în care codul folosește o mulțime de
timpul computerului. La fel, pentru că gcov acumulează statistici pe rând (la cel mai mic
rezoluție), funcționează cel mai bine cu un stil de programare care plasează doar o declarație pe fiecare
linia. Dacă utilizați macrocomenzi complicate care se extind la bucle sau la alte structuri de control,
statisticile sunt mai puțin utile --- raportează doar pe linia în care apelul macro
apare. Dacă macrocomenzile complexe se comportă ca niște funcții, le puteți înlocui cu inline
funcții pentru a rezolva această problemă.

gcov creează un fișier jurnal numit sourcefile.gcov care indică de câte ori fiecare rând de
un fișier sursă fişier sursă.c a executat. Puteți utiliza aceste fișiere jurnal împreună cu gprof la
ajută la reglarea fină a performanței programelor dvs. gprof vă oferă informații despre sincronizare
poate folosi împreună cu informațiile de la care obțineți gcov.

gcov funcționează numai pe codul compilat cu GCC. Nu este compatibil cu nicio altă profilare
sau mecanismul de acoperire a testelor.

OPŢIUNI

-h
--Ajutor
Afișați ajutor despre utilizare gcov (pe ieșirea standard) și ieșiți fără a face nimic
procesare ulterioara.

-v
--versiune
Afișați gcov numărul versiunii (pe ieșirea standard) și ieșiți fără a face nimic
procesare ulterioara.

-a
--toate blocurile
Scrieți numărul de execuții individuale pentru fiecare bloc de bază. În mod normal, iese gcov
execuția contează numai pentru blocurile principale ale unei linii. Cu această opțiune poți
determinați dacă blocurile dintr-o singură linie nu sunt executate.

-b
--ramură-probabilităţi
Scrieți frecvențele de ramificație în fișierul de ieșire și scrieți informațiile rezumate ale ramurilor în fișierul
ieșire standard. Această opțiune vă permite să vedeți cât de des fiecare ramură din programul dumneavoastră
a fost luat. Ramurile necondiționate nu vor fi afișate, cu excepția cazului în care -u este dată opțiunea.

-c
--ramură-numărătoare
Scrieți frecvențele de ramificație ca număr de ramuri luate, mai degrabă decât ca procent
de ramuri luate.

-n
--fără-ieșire
Nu creați gcov fisier de iesire.

-l
--long-file-names
Creați nume lungi de fișiere pentru fișierele sursă incluse. De exemplu, dacă fișierul antet xh
conține cod și a fost inclus în fișier ac, apoi alergând gcov pe dosar ac
va produce un fișier de ieșire numit ac##xhgcov în loc de xhgcov. Acesta poate fi
util dacă xh este inclus în mai multe fișiere sursă și doriți să vedeți persoana respectivă
contributii. Dacă utilizați -p opțiunea, atât numele fișierelor incluse, cât și cele incluse
vor fi nume de căi complete.

-p
--conserva-cărări
Păstrați informațiile complete ale căii în numele generate .gcov fișiere. Fără
această opțiune, este folosită doar componenta nume de fișier. Cu această opțiune, toate directoarele
sunt folosite, cu / caractere traduse în # caractere, . Componentele directorului au fost eliminate
și de nedemontat .. componente redenumite în ^. Acest lucru este util dacă fișierele sursă sunt în
mai multe directoare diferite.

-r
--numai-rudă
Produceți numai informații despre fișierele sursă cu o cale relativă (după sursă
eliziunea prefixului). Căile absolute sunt de obicei fișiere antet de sistem și acoperirea oricăror
funcțiile inline din acestea sunt în mod normal neinteresante.

-f
--rezumate-funcții
Rezumate de ieșire pentru fiecare funcție în plus față de rezumatul la nivel de fișier.

-o director|fișier
--director-obiect director
--fișier-obiect fişier
Specificați fie directorul care conține fișierele de date gcov, fie numele căii obiectului.
.gcno, și .gcda fișierele de date sunt căutate folosind această opțiune. Dacă un director este
specificat, fișierele de date se află în acel director și poartă numele după numele fișierului de intrare,
fără prelungirea lui. Dacă aici este specificat un fișier, fișierele de date sunt denumite după
acel fișier, fără extensia lui.

-s director
--source-prefix director
Un prefix pentru numele fișierelor sursă de eliminat la generarea fișierelor de acoperire de ieșire.
Această opțiune este utilă atunci când construiți într-un director separat și calea către
directorul sursă nu este dorit la determinarea numelor fișierelor de ieșire. Rețineți că aceasta
Detectarea prefixului este aplicată înainte de a determina dacă fișierul sursă este absolut.

-u
--ramuri-neconditionate
Când sunt date probabilitățile de ramuri, includeți-le pe cele ale ramurilor necondiționate.
Ramurile necondiționate nu sunt în mod normal interesante.

-d
--afișare-progres
Afișați progresul pe ieșirea standard.

-i
--format-intermediar
Ieșiți fișierul gcov într-un format de text intermediar ușor de analizat, care poate fi utilizat de lcov
sau alte instrumente. Ieșirea este una singură .gcov dosar per .gcda fişier. Nu există cod sursă
necesar.

Formatul intermediarului .gcov fișierul este text simplu, cu o intrare pe linie

fişier:
funcţie: , ,
număr: ,
ramura: ,

Unde este
notexec (sucursala neexecutata)
luat (Ramură executată și luată)
nottaken (Ramură executată, dar nu luată)

Pot fi multiple intrări într-un gcov intermediar
fişier. Toate intrările după a se referă la acel fișier sursă
pana la urmatoarea intrare.

Iată o mostră când -i este folosit împreună cu -b opţiune:

fișier:array.cc
funcția:11,1,_Z3sumRKSt6vectorIPiSaIS0_EE
functie:22,1,principal
număr: 11,1
număr: 12,1
număr: 14,1
ramură:14,luată
număr: 26,1
ramură: 28, nevăzut

-m
--nume-descurcat
Afișează numele funcțiilor demangle în ieșire. Implicit este să afișeze funcția alterată
nume.

gcov ar trebui să fie rulat cu directorul curent la fel ca atunci când ați invocat
compilator. În caz contrar, nu va putea localiza fișierele sursă. gcov produce fișiere
denumit mangledname.gcov în directorul curent. Acestea conțin informațiile de acoperire
a fișierului sursă căruia îi corespund. unu .gcov fișierul este produs pentru fiecare sursă (sau
antet) fișier care conține cod, care a fost compilat pentru a produce fișierele de date. The
nume stricat o parte din numele fișierului de ieșire este de obicei pur și simplu numele fișierului sursă, dar poate
fi ceva mai complicat dacă -l or -p sunt date optiuni. Consultați aceste opțiuni
pentru detalii.

Dacă invoci gcov cu mai multe fișiere de intrare, contribuțiile din fiecare fișier de intrare sunt
însumat. De obicei, îl invocați cu aceeași listă de fișiere ca și linkul final al
executabilul dvs.

.gcov fișierele conțin : câmpuri separate împreună cu codul sursă al programului. Formatul
is

: :

Informații suplimentare de bloc pot urma fiecare linie, atunci când sunt solicitate de opțiunea din linia de comandă.
execution_count is - pentru liniile care nu conțin cod. Liniile neexecutate sunt marcate #####
or ====, în funcție de dacă sunt accesibile pe căi neexceptionale sau numai
căi excepționale, cum ar fi handlerele de excepții C++, respectiv.

Unele linii de informații de la început au Numărul de linie de zero. Aceste rânduri de preambul sunt
a formei

-:0: :

Ordinea și numărul acestor linii de preambul vor fi mărite ca gcov dezvoltare
progresează --- nu te baza pe ele să rămână neschimbate. Utilizare etichetă pentru a localiza un anume
linia de preambul.

Informațiile suplimentare de bloc sunt de formular



informații este ușor de citit de om, dar conceput pentru a fi suficient de simplu pentru analizarea mașinii
prea.

La imprimarea procentelor, 0% și 100% sunt tipărite numai când valorile sunt exact 0% și
100% respectiv. Alte valori care ar fi rotunjite în mod convențional la 0% sau 100% sunt
în schimb tipărită ca cea mai apropiată valoare non-limită.

Atunci când se utilizează gcov, trebuie mai întâi să compilați programul cu două opțiuni speciale GCC:
-fprofil-arcuri -ftest-acoperire. Aceasta îi spune compilatorului să genereze suplimentar
informațiile necesare gcov (practic un grafic de flux al programului) și include, de asemenea
cod suplimentar în fișierele obiect pentru a genera informațiile suplimentare de profilare necesare
de gcov. Aceste fișiere suplimentare sunt plasate în directorul în care se află fișierul obiect
află.

Rularea programului va face ca rezultatul profilului să fie generat. Pentru fiecare fișier sursă
compilat cu -fprofil-arcuri, un însoțitor .gcda fișierul va fi plasat în fișierul obiect
director.

Alergare gcov cu numele fișierelor sursă ale programului dvs. ca argumente vor produce acum o listă
a codului împreună cu frecvența de execuție pentru fiecare linie. De exemplu, dacă programul dvs
se numește tmp.c, asta este ceea ce vezi când folosești elementul de bază gcov facilitate:

$ gcc -fprofile-arcs -ftest-coverage tmp.c
$ a.out
$ gcov tmp.c
90.00% din 10 linii sursă executate în fișierul tmp.c
Se creează tmp.c.gcov.

Fișierul tmp.c.gcov conţine ieşire de la gcov. Iată un exemplu:

-: 0:Sursa:tmp.c
-: 0:Graph:tmp.gcno
-: 0:Date:tmp.gcda
-: 0:Alerte:1
-: 0:Programe:1
-: 1:#include
-: 2:
-: 3:int main (void)
1: 4:{
1: 5: int i, total;
-: 6:
1: 7: total = 0;
-: 8:
11: 9: pentru (i = 0; i < 10; i++)
10: 10: total += i;
-: 11:
1: 12: dacă (total != 45)
#####: 13: printf ("Eșec\n");
-: 14: altfel
1: 15: printf ("Succes\n");
1: 16: întoarcere 0;
-: 17:}

Când utilizați -a opțiunea, veți obține un număr individual de blocuri, iar rezultatul arată
asa:

-: 0:Sursa:tmp.c
-: 0:Graph:tmp.gcno
-: 0:Date:tmp.gcda
-: 0:Alerte:1
-: 0:Programe:1
-: 1:#include
-: 2:
-: 3:int main (void)
1: 4:{
1: 4-bloc 0
1: 5: int i, total;
-: 6:
1: 7: total = 0;
-: 8:
11: 9: pentru (i = 0; i < 10; i++)
11: 9-bloc 0
10: 10: total += i;
10: 10-bloc 0
-: 11:
1: 12: dacă (total != 45)
1: 12-bloc 0
#####: 13: printf ("Eșec\n");
$$$$$: 13-bloc 0
-: 14: altfel
1: 15: printf ("Succes\n");
1: 15-bloc 0
1: 16: întoarcere 0;
1: 16-bloc 0
-: 17:}

În acest mod, fiecare bloc de bază este afișat doar pe o singură linie -- ultima linie a blocului. A
blocul cu mai multe linii va contribui doar la numărul de execuții al ultimei linii și altele
liniile nu vor fi afișate ca conțin cod, cu excepția cazului în care blocurile anterioare se termină pe acele linii. The
Este afișat numărul total de execuții al unei linii, iar liniile ulterioare arată numărul de execuții
pentru blocurile individuale care se termină pe acea linie. După fiecare bloc, ramura și apelul contează
al blocului va fi afișat, dacă -b este dată opțiunea.

Datorită modului în care instrumentele GCC apelează, un număr de apeluri poate fi afișat după o linie cu nr
blocuri individuale. După cum puteți vedea, linia 13 conține un bloc de bază care nu a fost executat.

Când utilizați -b opțiunea, rezultatul dvs. arată astfel:

$ gcov -b tmp.c
90.00% din 10 linii sursă executate în fișierul tmp.c
80.00% din 5 ramuri executate in fisierul tmp.c
80.00% din 5 ramuri luate cel puțin o dată în fișierul tmp.c
50.00% din 2 apeluri executate în fișierul tmp.c
Se creează tmp.c.gcov.

Iată o mostră a rezultatului tmp.c.gcov fișier:

-: 0:Sursa:tmp.c
-: 0:Graph:tmp.gcno
-: 0:Date:tmp.gcda
-: 0:Alerte:1
-: 0:Programe:1
-: 1:#include
-: 2:
-: 3:int main (void)
funcția principală numită 1 a returnat 1 blocuri executate 75%
1: 4:{
1: 5: int i, total;
-: 6:
1: 7: total = 0;
-: 8:
11: 9: pentru (i = 0; i < 10; i++)
ramura 0 luată 91% (cădere)
ramura 1 luată 9%
10: 10: total += i;
-: 11:
1: 12: dacă (total != 45)
ramura 0 luată 0% (cădere)
ramura 1 luată 100%
#####: 13: printf ("Eșec\n");
apelul 0 nu a fost niciodată executat
-: 14: altfel
1: 15: printf ("Succes\n");
apel 0 apelat 1 returnat 100%
1: 16: întoarcere 0;
-: 17:}

Pentru fiecare funcție, este tipărită o linie care arată de câte ori este apelată funcția, cum
de multe ori revine și ce procent din blocurile funcției au fost executate.

Pentru fiecare bloc de bază, se imprimă o linie după ultima linie a descrierii blocului de bază
ramura sau apelul care încheie blocul de bază. Pot exista mai multe ramuri și apeluri
listate pentru o singură linie sursă dacă există mai multe blocuri de bază care se termină pe acea linie.
În acest caz, filialelor și apelurilor li se atribuie fiecare un număr. Nu există o modalitate simplă de a
mapați aceste ramuri și apelurile înapoi la constructele sursă. În general, însă, cel mai scăzut
ramura sau apelul numerotat va corespunde constructului din stânga pe linia sursă.

Pentru o ramură, dacă a fost executată cel puțin o dată, atunci un procent care indică numărul de
de câte ori a fost luată ramura împărțită la numărul de ori a fost executată ramura va fi
tipărite. În caz contrar, este tipărit mesajul „niciodată executat”.

Pentru un apel, dacă a fost executat cel puțin o dată, atunci un procent care indică numărul de
ori apelul returnat împărțit la numărul de ori apelul a fost executat va fi
tipărite. Acesta va fi de obicei 100%, dar poate fi mai mic pentru funcțiile care numesc „ieșire” sau
„longjmp” și, prin urmare, este posibil să nu revină de fiecare dată când sunt apelați.

Numărările de execuție sunt cumulative. Dacă programul exemplu ar fi executat din nou fără
eliminarea .gcda fișier, numărul de ori pentru fiecare linie din sursă a fost
executate ar fi adăugate la rezultatele executării anterioare. Acest lucru este potențial util
în mai multe feluri. De exemplu, ar putea fi folosit pentru a acumula date pe un număr de
programul rulează ca parte a unei suite de verificare a testelor sau pentru a oferi o mai mare precizie pe termen lung
informații pentru un număr mare de rulări de program.

Datele din .gcda fișierele sunt salvate imediat înainte de ieșirea programului. Pentru fiecare
fișier sursă compilat cu -fprofil-arcuri, codul de profilare încearcă mai întâi să citească într-un
existent .gcda fişier; dacă fișierul nu se potrivește cu executabilul (număr diferit de fișiere de bază
blocarea numărului) va ignora conținutul fișierului. Apoi se adaugă în noua execuție
numără și în cele din urmă scrie datele în fișier.

Utilizarea gcov cu CGC Optimizare

Dacă intenționați să utilizați gcov pentru a vă ajuta să optimizați codul, trebuie mai întâi să vă compilați programul
cu două opțiuni speciale GCC: -fprofil-arcuri -ftest-acoperire. În afară de asta, poți
utilizați orice alte opțiuni GCC; dar dacă vrei să demonstrezi că fiecare linie din programul tău
a fost executat, nu ar trebui să compilați cu optimizare în același timp. La unele mașini
optimizatorul poate elimina unele linii de cod simple combinându-le cu alte linii.
De exemplu, codul ca acesta:

dacă (a != b)
c = 1;
altfel
c = 0;

poate fi compilat într-o singură instrucțiune pe unele mașini. În acest caz, nu există nicio modalitate de
gcov pentru a calcula numere separate de execuție pentru fiecare linie, deoarece nu există separat
cod pentru fiecare linie. De aici gcov ieșirea arată așa dacă ați compilat programul
cu optimizare:

100: 12: dacă (a != b)
100: 13: c = 1;
100:14:altfel
100: 15: c = 0;

Rezultatul arată că acest bloc de cod, combinat prin optimizare, a fost executat de 100 de ori.
Într-un sens, acest rezultat este corect, deoarece a existat o singură instrucțiune reprezentând
toate aceste patru rânduri. Cu toate acestea, rezultatul nu indică de câte ori este rezultat
a fost 0 și de câte ori rezultatul a fost 1.

Funcțiile inlineabile pot crea numere de linii neașteptate. Numărările de linii sunt afișate pentru
codul sursă al funcției inlineabile, dar ceea ce este afișat depinde de locul în care se află funcția
înliniat, sau dacă nu este deloc înliniat.

Dacă funcția nu este aliniată, compilatorul trebuie să emită o copie în afara liniei
funcție, în orice fișier obiect care are nevoie de ea. Dacă dosarA.o și dosarB.o ambele contin din
corpuri de linie ale unei anumite funcții inlineabile, ambele vor conține, de asemenea, acoperire
contează pentru acea funcție. Cand dosarA.o și dosarB.o sunt legate între ele, linkerul va,
pe multe sisteme, selectați unul dintre acele corpuri din afara liniilor pentru toate apelurile către acea funcție,
și eliminați sau ignorați celălalt. Din păcate, nu va elimina contoarele de acoperire
pentru corpul funcțional neutilizat. Prin urmare, atunci când sunt instrumentate, toate, cu excepția uneia, folosesc această funcție
va afișa zero numărări.

Dacă funcția este aliniată în mai multe locuri, structura blocului din fiecare locație ar putea
sa nu fie la fel. De exemplu, o condiție ar putea fi acum calculabilă la momentul compilării în
unele cazuri. Deoarece acoperirea tuturor utilizărilor funcției inline va fi afișată
pentru aceleași linii sursă, numărul liniilor în sine ar putea părea inconsecvente.

Aplicațiile cu funcționare lungă pot folosi facilitățile „_gcov_reset” și „_gcov_dump” pentru
restricționați colectarea profilului la regiunea de interes a programului. Apelarea „_gcov_reset(void)”
va șterge toate contoarele de profil la zero, iar apelarea „_gcov_dump(void)” va cauza
informațiile de profil colectate la acel moment pentru a fi trimise .gcda fișiere de ieșire.

Utilizați mips64-linux-gnuabi64-gcov-5 online folosind serviciile onworks.net