sh4-linux-gnu-gcov - Online sa Cloud

PROGRAMA:

NAME

gcov - tool sa pagsubok sa saklaw

SINOPSIS

gcov [-v|--bersyon] [-h|- Tumulong]
[-a|--lahat ng mga bloke]
[-b|--branch-probability]
[-c|--branch-counts]
[-d|--display-progress]
[-f|--function-summaries]
[-i|--intermediate-format]
[-l|--mahabang-file-name]
[-m|--demangled-pangalan]
[-n|--walang-output]
[-o|--object-directory direktoryo|file]
[-p|--preserve-paths]
[-r|--kamag-anak-lamang]
[-s|--source-prefix direktoryo]
[-u|--walang kondisyon-mga sanga]
file

DESCRIPTION

gcov ay isang test coverage program. Gamitin ito kasabay ng GCC para pag-aralan ang iyong mga programa
tumulong na lumikha ng mas mahusay, mas mabilis na pagpapatakbo ng code at upang matuklasan ang mga hindi pa nasusubukang bahagi ng iyong
programa. Pwede mong gamitin gcov bilang isang tool sa pag-profile upang makatulong na matuklasan kung saan ang iyong pag-optimize
Ang mga pagsisikap ay pinakamahusay na makakaapekto sa iyong code. Maaari mo ring gamitin gcov kasama ang iba pang profiling
tool, gprof, upang masuri kung aling mga bahagi ng iyong code ang gumagamit ng pinakamaraming oras ng pag-compute.

Tinutulungan ka ng mga tool sa pag-profile na suriin ang pagganap ng iyong code. Paggamit ng profiler tulad ng gcov
or gprof, maaari mong malaman ang ilang pangunahing istatistika ng pagganap, gaya ng:

* kung gaano kadalas naisasagawa ang bawat linya ng code

* anong mga linya ng code ang aktwal na naisakatuparan

* kung gaano karaming oras sa pag-compute ang ginagamit ng bawat seksyon ng code

Kapag alam mo na ang mga bagay na ito tungkol sa kung paano gumagana ang iyong code kapag pinagsama-sama, maaari mong tingnan ang bawat isa
module upang makita kung aling mga module ang dapat i-optimize. gcov tumutulong sa iyo na matukoy kung saan magtatrabaho
sa pag-optimize.

Gumagamit din ang mga developer ng software ng coverage testing kasabay ng mga testsuite, para makasigurado
Ang software ay talagang sapat na mabuti para sa isang release. Maaaring i-verify ng mga Testsuite na isang programa
gumagana tulad ng inaasahan; ang isang programa sa saklaw ay sumusubok upang makita kung gaano karami ng programa ang ginagamit ng
ang testsuite. Matutukoy ng mga developer kung anong uri ng mga test case ang kailangang idagdag
ang mga testsuite upang lumikha ng parehong mas mahusay na pagsubok at isang mas mahusay na huling produkto.

Dapat mong i-compile ang iyong code nang walang pag-optimize kung plano mong gamitin gcov dahil ang
optimization, sa pamamagitan ng pagsasama-sama ng ilang linya ng code sa isang function, ay maaaring hindi gaanong maibigay sa iyo
impormasyon dahil kailangan mong maghanap ng `mga hot spot' kung saan ang code ay gumagamit ng napakaraming bagay
oras ng kompyuter. Ganun din, kasi gcov nag-iipon ng mga istatistika ayon sa linya (sa pinakamababa
resolution), ito ay pinakamahusay na gumagana sa isang programming style na naglalagay lamang ng isang pahayag sa bawat isa
linya. Kung gumagamit ka ng mga kumplikadong macro na lumalawak sa mga loop o sa iba pang mga istruktura ng kontrol,
ang mga istatistika ay hindi gaanong nakakatulong---nag-uulat lamang sila sa linya kung saan tumatawag ang macro
lilitaw. Kung ang iyong mga kumplikadong macro ay kumikilos tulad ng mga function, maaari mong palitan ang mga ito ng inline
mga function upang malutas ang problemang ito.

gcov lumilikha ng isang logfile na tinatawag sourcefile.gcov na nagsasaad kung gaano karaming beses ang bawat linya ng
isang source file sourcefile.c ay naisakatuparan. Maaari mong gamitin ang mga logfile na ito kasama ng gprof sa
tumulong sa pag-fine-tune ng pagganap ng iyong mga programa. gprof nagbibigay sa iyo ng impormasyon sa oras
maaaring gamitin kasama ng impormasyong makukuha mo gcov.

gcov gumagana lamang sa code na pinagsama-sama sa GCC. Hindi ito tugma sa anumang iba pang pag-profile
o mekanismo ng saklaw ng pagsubok.

Opsyon

-h
- Tumulong
Ipakita ang tulong tungkol sa paggamit gcov (sa karaniwang output), at lumabas nang walang ginagawa
karagdagang pagproseso.

-v
--bersyon
Ipakita ang gcov numero ng bersyon (sa karaniwang output), at lumabas nang walang ginagawa
karagdagang pagproseso.

-a
--lahat ng mga bloke
Sumulat ng mga indibidwal na bilang ng pagpapatupad para sa bawat pangunahing bloke. Karaniwang gcov outputs
ang pagpapatupad ay binibilang lamang para sa mga pangunahing bloke ng isang linya. Sa pagpipiliang ito magagawa mo
matukoy kung ang mga bloke sa loob ng isang linya ay hindi isinasagawa.

-b
--branch-probability
Isulat ang mga frequency ng sangay sa output file, at isulat ang impormasyon ng buod ng sangay sa
karaniwang output. Binibigyang-daan ka ng opsyong ito na makita kung gaano kadalas ang bawat sangay sa iyong programa
ay kinunan. Ang mga unconditional branch ay hindi ipapakita, maliban kung ang -u ang pagpipilian ay ibinigay.

-c
--branch-counts
Isulat ang mga frequency ng sangay bilang ang bilang ng mga sangay na kinuha, sa halip na ang porsyento
ng mga sangay na kinuha.

-n
--walang-output
Huwag lumikha ng gcov output file.

-l
--mahabang-file-name
Gumawa ng mahahabang pangalan ng file para sa mga kasamang source file. Halimbawa, kung ang header file xh
naglalaman ng code, at isinama sa file ac, tapos tumakbo gcov sa file ac
gagawa ng isang output file na tinatawag na ac##xhgcov sa halip ng xhgcov. Maaari itong maging
kapaki-pakinabang kung xh ay kasama sa maraming source file at gusto mong makita ang indibidwal
mga kontribusyon. Kung gagamitin mo ang -p opsyon, parehong kasama at kasama ang mga pangalan ng file
magiging kumpletong mga pangalan ng landas.

-p
--preserve-paths
Panatilihin ang kumpletong impormasyon ng landas sa mga pangalan ng nabuo .gcov mga file. Kung wala
ang pagpipiliang ito, ang bahagi lamang ng filename ang ginagamit. Gamit ang pagpipiliang ito, lahat ng mga direktoryo
ay ginagamit, na may / mga character na isinalin sa # mga character, . tinanggal ang mga bahagi ng direktoryo
at hindi maalis .. mga bahagi na pinalitan ng pangalan sa ^. Ito ay kapaki-pakinabang kung ang mga sourcefile ay nasa
ilang iba't ibang mga direktoryo.

-r
--kamag-anak-lamang
I-output lamang ang impormasyon tungkol sa mga source file na may kaugnay na pathname (pagkatapos ng source
pagtanggal ng prefix). Ang mga absolute path ay karaniwang mga file ng header ng system at saklaw ng anuman
Ang mga inline na function doon ay karaniwang hindi kawili-wili.

-f
--function-summaries
Mga buod ng output para sa bawat function bilang karagdagan sa buod ng antas ng file.

-o direktoryo|file
--object-directory direktoryo
--object-file file
Tukuyin ang alinman sa direktoryo na naglalaman ng mga file ng data ng gcov, o ang pangalan ng object path.
Ang .gcno, at .gcda Hinahanap ang mga file ng data gamit ang opsyong ito. Kung ang isang direktoryo ay
tinukoy, ang mga file ng data ay nasa direktoryo na iyon at pinangalanan pagkatapos ng pangalan ng input file,
nang walang extension nito. Kung ang isang file ay tinukoy dito, ang mga file ng data ay pinangalanan pagkatapos
ang file na iyon, nang walang extension nito.

-s direktoryo
--source-prefix direktoryo
Isang prefix para sa mga pangalan ng source file na aalisin kapag bumubuo ng mga output coverage file.
Ang pagpipiliang ito ay kapaki-pakinabang kapag bumubuo sa isang hiwalay na direktoryo, at ang pathname sa
hindi gusto ang direktoryo ng pinagmulan kapag tinutukoy ang mga pangalan ng output file. Tandaan na ito
inilapat ang prefix detection bago matukoy kung ang source file ay ganap.

-u
--walang kondisyon-mga sanga
Kapag ibinigay ang mga probabilidad ng sangay, isama ang mga sanga na walang kondisyon.
Ang mga unconditional branch ay karaniwang hindi kawili-wili.

-d
--display-progress
Ipakita ang progreso sa karaniwang output.

-i
--intermediate-format
I-output ang gcov file sa isang madaling i-parse na intermediate na format ng text na magagamit ng lcov
o iba pang kasangkapan. Ang output ay isang solong .gcov file sa bawat .gcda file. Walang source code
kinakailangan.

Ang format ng intermediate .gcov Ang file ay plain text na may isang entry sa bawat linya

file:
function: , ,
lbilang: ,
sangay: ,

Kung saan ang ay
notexec (Hindi naisakatuparan ang sangay)
kinuha (Branch executed and taken)
hindi kinukuha (Branch executed, but not taken)

Maaaring magkaroon ng maramihan mga entry sa isang intermediate gcov
file. Lahat ng mga entry na sumusunod sa a nauukol sa source file na iyon
hanggang sa susunod pagpasok.

Narito ang isang sample kung kailan -i ay ginagamit kasabay ng -b opsiyon:

file:array.cc
function:11,1,_Z3sumRKSt6vectorIPiSaIS0_EE
function:22,1,pangunahing
lbilang:11,1
lbilang:12,1
lbilang:14,1
sangay:14, kinuha
lbilang:26,1
sangay:28, hindi nakuha

-m
--demangled-pangalan
Ipakita ang mga demangled na pangalan ng function sa output. Ang default ay upang ipakita ang sira na function
mga pangalan.

gcov ay dapat na patakbuhin kasama ang kasalukuyang direktoryo na kapareho ng noong tinawag mo ang
compiler. Kung hindi, hindi nito mahahanap ang mga source file. gcov gumagawa ng mga file
tinatawag mangledname.gcov sa kasalukuyang direktoryo. Ang mga ito ay naglalaman ng impormasyon sa saklaw
ng source file kung saan sila tumutugma. Isa .gcov file ay ginawa para sa bawat pinagmulan (o
header) na file na naglalaman ng code, na pinagsama-sama upang makagawa ng mga file ng data. Ang
mangledname bahagi ng pangalan ng file ng output ay karaniwang ang pangalan ng source file, ngunit maaari
maging isang bagay na mas kumplikado kung ang -l or -p ibinibigay ang mga pagpipilian. Sumangguni sa mga opsyon na iyon
para sa mga detalye.

Kung mag-invoke ka gcov na may maraming input file, ang mga kontribusyon mula sa bawat input file ay
summed. Karaniwang hihingin mo ito sa parehong listahan ng mga file bilang panghuling link ng
iyong executable.

Ang .gcov ang mga file ay naglalaman ng : pinaghiwalay na mga field kasama ang source code ng program. Ang format
is

: :

Maaaring magtagumpay ang karagdagang impormasyon ng block sa bawat linya, kapag hiniling ng opsyon sa command line.
Ang execution_count is - para sa mga linyang walang code. Minarkahan ang mga hindi naisagawang linya #####
or ====, depende sa kung maaabot ang mga ito sa pamamagitan ng hindi pambihirang mga landas o lamang
pambihirang mga landas tulad ng C++ exception handler, ayon sa pagkakabanggit.

May ilang linya ng impormasyon sa simula numero ng linya ng zero. Ang mga preamble lines na ito ay
ng anyo

-:0: :

Ang pagkakasunud-sunod at bilang ng mga linya ng preamble na ito ay madaragdagan bilang gcov pag-unlad
umuunlad --- huwag umasa sa kanila na nananatiling hindi nagbabago. Gamitin mga tag upang mahanap ang isang partikular
linya ng pambungad.

Ang karagdagang impormasyon ng block ay nasa form



Ang impormasyon ay nababasa ng tao, ngunit idinisenyo upang maging sapat na simple para sa pag-parse ng makina
masyadong.

Kapag nagpi-print ng mga porsyento, 0% at 100% ay naka-print lamang kapag ang mga halaga ay tamang-tama 0% at
100% ayon sa pagkakabanggit. Ang iba pang mga value na karaniwang bi-round sa 0% o 100% ay
sa halip ay naka-print bilang ang pinakamalapit na hindi hangganan na halaga.

Kapag gumagamit gcov, kailangan mo munang i-compile ang iyong program na may dalawang espesyal na opsyon sa GCC:
-fprofile-arcs -ftest-saklaw. Sinasabi nito sa compiler na bumuo ng karagdagang
impormasyong kailangan ng gcov (karaniwang isang flow graph ng programa) at kasama rin
karagdagang code sa mga object file para sa pagbuo ng karagdagang impormasyon sa pag-profile na kailangan
ni gcov. Ang mga karagdagang file na ito ay inilalagay sa direktoryo kung nasaan ang object file
matatagpuan.

Ang pagpapatakbo ng programa ay magiging sanhi ng pagbuo ng output ng profile. Para sa bawat source file
pinagsama-sama sa -fprofile-arcs, isang kasamang .gcda file ay ilalagay sa object file
direktoryo.

Tumatakbo gcov gamit ang mga pangalan ng source file ng iyong programa bilang mga argumento ay gagawa na ngayon ng isang listahan
ng code kasama ang dalas ng pagpapatupad para sa bawat linya. Halimbawa, kung ang iyong programa
ay tinatawag na tmp.c, ito ang makikita mo kapag ginamit mo ang basic gcov pasilidad:

$ gcc -fprofile-arcs -ftest-coverage tmp.c
$a.out
$ gcov tmp.c
90.00% ng 10 source na linya ang naisagawa sa file tmp.c
Ginagawa ang tmp.c.gcov.

Ang file tmp.c.gcov naglalaman ng output mula sa gcov. Narito ang isang sample:

-: 0:Pinagmulan:tmp.c
-: 0:Graph:tmp.gcno
-: 0:Data:tmp.gcda
-: 0: Tumatakbo:1
-: 0:Mga Programa:1
-: 1:#isama
-: 2:
-: 3:int main (walang bisa)
1:4:{
1: 5: int i, kabuuan;
-: 6:
1: 7: kabuuan = 0;
-: 8:
11: 9: para sa (i = 0; i < 10; i++)
10: 10: kabuuang += i;
-: 11:
1: 12: kung (kabuuan!= 45)
#####: 13: printf ("Pagkabigo\n");
-: 14: iba pa
1: 15: printf ("Tagumpay\n");
1: 16: bumalik 0;
-: 17:}

Kapag ginamit mo ang -a opsyon, makakakuha ka ng mga indibidwal na bilang ng bloke, at ang hitsura ng output
ganito:

-: 0:Pinagmulan:tmp.c
-: 0:Graph:tmp.gcno
-: 0:Data:tmp.gcda
-: 0: Tumatakbo:1
-: 0:Mga Programa:1
-: 1:#isama
-: 2:
-: 3:int main (walang bisa)
1:4:{
1: 4-block 0
1: 5: int i, kabuuan;
-: 6:
1: 7: kabuuan = 0;
-: 8:
11: 9: para sa (i = 0; i < 10; i++)
11: 9-block 0
10: 10: kabuuang += i;
10: 10-block 0
-: 11:
1: 12: kung (kabuuan!= 45)
1: 12-block 0
#####: 13: printf ("Pagkabigo\n");
$$$$$: 13-block 0
-: 14: iba pa
1: 15: printf ("Tagumpay\n");
1: 15-block 0
1: 16: bumalik 0;
1: 16-block 0
-: 17:}

Sa mode na ito, ang bawat pangunahing bloke ay ipinapakita lamang sa isang linya -- ang huling linya ng bloke. A
multi-line block ay mag-aambag lamang sa execution count ng huling linyang iyon, at iba pa
ang mga linya ay hindi ipapakita na naglalaman ng code, maliban kung ang mga nakaraang bloke ay magtatapos sa mga linyang iyon. Ang
Ang kabuuang bilang ng pagpapatupad ng isang linya ay ipinapakita at ang mga kasunod na linya ay nagpapakita ng mga bilang ng pagpapatupad
para sa mga indibidwal na bloke na nagtatapos sa linyang iyon. Pagkatapos ng bawat bloke, binibilang ang sangay at tawag
ng block ay ipapakita, kung ang -b ang pagpipilian ay ibinigay.

Dahil sa paraan ng pagtawag ng mga instrumento ng GCC, maaaring ipakita ang bilang ng tawag pagkatapos ng linyang may no
indibidwal na mga bloke. Tulad ng nakikita mo, ang linya 13 ay naglalaman ng isang pangunahing bloke na hindi naisakatuparan.

Kapag ginamit mo ang -b opsyon, ganito ang hitsura ng iyong output:

$ gcov -b tmp.c
90.00% ng 10 source na linya ang naisagawa sa file tmp.c
80.00% ng 5 sangay na naisakatuparan sa file tmp.c
80.00% ng 5 sangay na kinuha kahit isang beses sa file tmp.c
50.00% ng 2 tawag na ginawa sa file tmp.c
Ginagawa ang tmp.c.gcov.

Narito ang isang sample ng isang resulta tmp.c.gcov file:

-: 0:Pinagmulan:tmp.c
-: 0:Graph:tmp.gcno
-: 0:Data:tmp.gcda
-: 0: Tumatakbo:1
-: 0:Mga Programa:1
-: 1:#isama
-: 2:
-: 3:int main (walang bisa)
function na pangunahing tinatawag na 1 nagbalik ng 1 bloke na naisakatuparan 75%
1:4:{
1: 5: int i, kabuuan;
-: 6:
1: 7: kabuuan = 0;
-: 8:
11: 9: para sa (i = 0; i < 10; i++)
branch 0 kinuha 91% (fallthrough)
branch 1 kinuha 9%
10: 10: kabuuang += i;
-: 11:
1: 12: kung (kabuuan!= 45)
branch 0 kinuha 0% (fallthrough)
branch 1 kinuha 100%
#####: 13: printf ("Pagkabigo\n");
ang tawag 0 ay hindi kailanman naisakatuparan
-: 14: iba pa
1: 15: printf ("Tagumpay\n");
ibinalik ang tawag sa 0 na tinatawag na 1 100%
1: 16: bumalik 0;
-: 17:}

Para sa bawat function, may naka-print na linya na nagpapakita kung gaano karaming beses tinawag ang function, kung paano
maraming beses itong bumabalik at ilang porsyento ng mga bloke ng function ang naisakatuparan.

Para sa bawat pangunahing bloke, ang isang linya ay naka-print pagkatapos ng huling linya ng pangunahing bloke na naglalarawan
ang sangay o tawag na nagtatapos sa pangunahing bloke. Maaaring mayroong maraming sangay at tawag
nakalista para sa isang linya ng pinagmulan kung mayroong maraming pangunahing mga bloke na nagtatapos sa linyang iyon.
Sa kasong ito, ang mga sangay at tawag ay binibigyan ng numero bawat isa. Walang simpleng paraan para
imapa ang mga sangay na ito at tumatawag pabalik sa mga pinagmumulan ng konstruksyon. Sa pangkalahatan, bagaman, ang pinakamababa
ang may bilang na sangay o tawag ay tumutugma sa pinakakaliwang konstruksyon sa pinagmulang linya.

Para sa isang sangay, kung ito ay naisakatuparan ng hindi bababa sa isang beses, pagkatapos ay isang porsyento na nagsasaad ng bilang ng
beses na kinuha ang sangay na hinati sa bilang ng beses na naisakatuparan ang sangay
nakalimbag. Kung hindi, ang mensaheng "never executed" ay naka-print.

Para sa isang tawag, kung ito ay naisakatuparan ng hindi bababa sa isang beses, pagkatapos ay isang porsyento na nagsasaad ng bilang ng
beses na ibinalik ang tawag na hinati sa bilang ng beses na ginawa ang tawag
nakalimbag. Ito ay karaniwang magiging 100%, ngunit maaaring mas mababa para sa mga function na tinatawag na "exit" o
"longjmp", at sa gayon ay maaaring hindi bumalik sa tuwing tatawagin sila.

Ang mga bilang ng pagpapatupad ay pinagsama-sama. Kung ang halimbawang programa ay naisakatuparan muli nang wala
inaalis ang .gcda file, ang bilang para sa bilang ng beses sa bawat linya sa pinagmulan ay
ang naisakatuparan ay idaragdag sa mga resulta ng nakaraang (mga) run. Ito ay potensyal na kapaki-pakinabang
sa ilang paraan. Halimbawa, maaari itong magamit upang makaipon ng data sa isang bilang ng
tumatakbo ang programa bilang bahagi ng isang suite ng pag-verify ng pagsubok, o upang magbigay ng mas tumpak na pangmatagalang
impormasyon sa isang malaking bilang ng mga pagpapatakbo ng programa.

Ang data sa .gcda Ang mga file ay nai-save kaagad bago lumabas ang programa. Para sa bawat isa
source file na pinagsama-sama sa -fprofile-arcs, ang profiling code ay unang sumusubok na basahin sa isang
nabubuhay .gcda file; kung ang file ay hindi tumutugma sa executable (magkaibang bilang ng basic
block counts) hindi nito papansinin ang mga nilalaman ng file. Pagkatapos ay nagdaragdag ito sa bagong pagpapatupad
binibilang at sa wakas ay nagsusulat ng data sa file.

paggamit gcov sa GCC Optimization

Kung balak mong gamitin gcov para makatulong sa pag-optimize ng iyong code, kailangan mo munang i-compile ang iyong program
na may dalawang espesyal na opsyon sa GCC: -fprofile-arcs -ftest-saklaw. Aside from that, kaya mo
gumamit ng anumang iba pang opsyon sa GCC; ngunit kung gusto mong patunayan na ang bawat solong linya sa iyong programa
ay naisakatuparan, hindi ka dapat mag-compile sa pag-optimize nang sabay. Sa ilang mga makina
maaaring alisin ng optimizer ang ilang simpleng linya ng code sa pamamagitan ng pagsasama-sama ng mga ito sa iba pang linya.
Halimbawa, ang code na tulad nito:

kung (a!= b)
c = 1;
iba
c = 0;

maaaring isama sa isang pagtuturo sa ilang mga makina. Sa kasong ito, walang paraan para sa
gcov upang kalkulahin ang hiwalay na mga bilang ng pagpapatupad para sa bawat linya dahil walang hiwalay
code para sa bawat linya. Kaya ang gcov ganito ang hitsura ng output kung pinagsama-sama mo ang programa
na may pag-optimize:

100: 12: kung (a != b)
100: 13: c = 1;
100: 14: iba pa
100: 15: c = 0;

Ipinapakita ng output na ang bloke ng code na ito, na pinagsama ng pag-optimize, ay naisakatuparan ng 100 beses.
Sa isang kahulugan, tama ang resultang ito, dahil iisa lang ang pagtuturo na kumakatawan
lahat ng apat na linyang ito. Gayunpaman, hindi ipinapahiwatig ng output kung gaano karaming beses ang resulta
ay 0 at kung gaano karaming beses ang resulta ay 1.

Ang mga inlineable na function ay maaaring lumikha ng mga hindi inaasahang bilang ng linya. Ang mga bilang ng linya ay ipinapakita para sa
source code ng inlineable na function, ngunit ang ipinapakita ay depende sa kung nasaan ang function
inline, o kung wala man lang inline.

Kung ang function ay hindi inlined, ang compiler ay dapat maglabas ng out of line na kopya ng
function, sa anumang object file na nangangailangan nito. Kung fileA.o at fileB.o parehong naglalaman ng
line body ng isang partikular na inlineable function, pareho din silang maglalaman ng coverage
binibilang para sa function na iyon. Kailan fileA.o at fileB.o ay magkakaugnay, ang nag-uugnay ay,
sa maraming system, pumili ng isa sa mga out of line na katawan para sa lahat ng tawag sa function na iyon,
at alisin o huwag pansinin ang isa pa. Sa kasamaang palad, hindi nito aalisin ang mga coverage counter
para sa hindi nagamit na function body. Kaya kapag ginamit, lahat maliban sa isang paggamit ng function na iyon
magpapakita ng mga zero count.

Kung ang function ay naka-inline sa ilang lugar, ang block structure sa bawat lokasyon ay maaaring
hindi maging pareho. Halimbawa, ang isang kundisyon ay maaari na ngayong kalkulahin sa oras ng pag-compile
ilang pagkakataon. Dahil ang saklaw ng lahat ng paggamit ng inline na function ay ipapakita
para sa parehong mga linya ng pinagmulan, ang mismong pagbibilang ng linya ay maaaring mukhang hindi pare-pareho.

Maaaring gamitin ng mga matagal nang application ang mga pasilidad na "_gcov_reset" at "_gcov_dump" upang
paghigpitan ang pagkolekta ng profile sa rehiyon ng interes ng programa. Tinatawagan ang "_gcov_reset(void)"
iki-clear ang lahat ng profile counter sa zero, at ang pagtawag sa "_gcov_dump(void)" ay magiging sanhi ng
impormasyon sa profile na nakolekta sa puntong iyon na itatapon sa .gcda mga output file.

Gumamit ng sh4-linux-gnu-gcov online gamit ang mga serbisyo ng onworks.net