alpha-linux-gnu-gcov-5 - ອອນລາຍໃນຄລາວ

ໂຄງການ:

NAME

gcov - coverage testing tool

ສະຫຼຸບສັງລວມ

gcov [-v|- ການປ່ຽນແປງ] [-h|- ຊ່ວຍ]
[-a|--ຕັນທັງໝົດ]
[-b|--ສາຂາ-ຄວາມເປັນໄປໄດ້]
[-c|--ສາຂາ-ນັບ]
[-d|--ສະແດງ-ຄວາມຄືບໜ້າ]
[-f|--function-ສະຫຼຸບ]
[-i|--intermediate-format]
[-l|--long-file-names]
[-m|--demangled-ຊື່]
[-n|--no-output]
[-o|--object-directory ໄດເລກະທໍລີ|ໄຟລ໌]
[-p|-- ຮັກສາເສັ້ນທາງ]
[-r|--ພີ່ນ້ອງເທົ່ານັ້ນ]
[-s|--source-prefix ລະບົບ]
[-u|--ສາຂາທີ່ບໍ່ມີເງື່ອນໄຂ]
ໄຟ

ລາຍລະອຽດ

gcov ແມ່ນໂຄງການຄຸ້ມຄອງການທົດສອບ. ໃຊ້ມັນຢູ່ໃນຄອນເສີດກັບ GCC ເພື່ອວິເຄາະໂຄງການຂອງທ່ານ
ຊ່ວຍສ້າງລະຫັດທີ່ເຮັດວຽກໄດ້ໄວຂຶ້ນ ແລະມີປະສິດທິພາບຫຼາຍຂຶ້ນ ແລະຄົ້ນພົບພາກສ່ວນທີ່ບໍ່ໄດ້ທົດສອບຂອງເຈົ້າ
ໂຄງການ. ທ່ານສາມາດນໍາໃຊ້ gcov ເປັນເຄື່ອງມືການສ້າງໂປຣໄຟລ໌ເພື່ອຊ່ວຍຄົ້ນພົບບ່ອນທີ່ການເພີ່ມປະສິດທິພາບຂອງທ່ານ
ຄວາມພະຍາຍາມທີ່ດີທີ່ສຸດຈະສົ່ງຜົນກະທົບຕໍ່ລະຫັດຂອງທ່ານ. ນອກນັ້ນທ່ານຍັງສາມາດນໍາໃຊ້ gcov ຄຽງຄູ່ກັບການສ້າງໂປຣໄຟລ໌ອື່ນໆ
ເຄື່ອງມື, ກປ, ເພື່ອປະເມີນວ່າສ່ວນໃດຂອງລະຫັດຂອງທ່ານໃຊ້ຈໍານວນເວລາຄອມພິວເຕີ້ຫຼາຍທີ່ສຸດ.

ເຄື່ອງມືສ້າງໂປຣໄຟລ໌ຊ່ວຍໃຫ້ທ່ານວິເຄາະປະສິດທິພາບຂອງລະຫັດຂອງທ່ານ. ການນໍາໃຊ້ profiler ເຊັ່ນ: gcov
or ກປ, ທ່ານສາມາດຊອກຫາສະຖິຕິການປະຕິບັດພື້ນຖານບາງຢ່າງ, ເຊັ່ນ:

* ແຕ່ລະສາຍຂອງລະຫັດປະຕິບັດເລື້ອຍໆສໍ່າໃດ

* ເສັ້ນລະຫັດໃດຖືກປະຕິບັດຕົວຈິງ

* ເວລາຄອມພິວເຕີແຕ່ລະພາກສ່ວນໃຊ້ລະຫັດເທົ່າໃດ

ເມື່ອທ່ານຮູ້ສິ່ງເຫຼົ່ານີ້ກ່ຽວກັບວິທີການລະຫັດຂອງທ່ານເຮັດວຽກໃນເວລາທີ່ລວບລວມ, ທ່ານສາມາດເບິ່ງແຕ່ລະ
ໂມດູນເພື່ອເບິ່ງວ່າໂມດູນໃດຄວນຖືກປັບແຕ່ງ. gcov ຊ່ວຍໃຫ້ທ່ານກໍານົດບ່ອນເຮັດວຽກ
ກ່ຽວກັບການເພີ່ມປະສິດທິພາບ.

ນັກພັດທະນາຊອບແວຍັງໃຊ້ການທົດສອບການຄຸ້ມຄອງໃນຄອນເສີດກັບ testsuites, ເພື່ອໃຫ້ແນ່ໃຈວ່າ
ຊອບແວແມ່ນດີພຽງພໍສໍາລັບການປ່ອຍ. Testsuites ສາມາດກວດສອບວ່າໂຄງການ
ເຮັດວຽກຕາມທີ່ຄາດໄວ້; ການທົດສອບໂຄງການຄຸ້ມຄອງເພື່ອເບິ່ງວ່າໂຄງການຖືກປະຕິບັດຫຼາຍປານໃດ
testsuite ໄດ້. ຫຼັງຈາກນັ້ນ, ນັກພັດທະນາສາມາດກໍານົດປະເພດຂອງກໍລະນີການທົດສອບທີ່ຕ້ອງໄດ້ຮັບການເພີ່ມໃສ່
testsuites ເພື່ອສ້າງທັງສອງການທົດສອບທີ່ດີກວ່າແລະຜະລິດຕະພັນສຸດທ້າຍທີ່ດີກວ່າ.

ທ່ານຄວນລວບລວມລະຫັດຂອງທ່ານໂດຍບໍ່ມີການເພີ່ມປະສິດທິພາບຖ້າທ່ານວາງແຜນທີ່ຈະໃຊ້ gcov ເນື່ອງຈາກວ່າ
ການເພີ່ມປະສິດທິພາບ, ໂດຍການລວມບາງສາຍຂອງລະຫັດເຂົ້າໄປໃນຫນຶ່ງຫນ້າທີ່, ອາດຈະບໍ່ໃຫ້ທ່ານຫຼາຍ
ຂໍ້​ມູນ​ທີ່​ທ່ານ​ຕ້ອງ​ການ​ເພື່ອ​ຊອກ​ຫາ 'ຈຸດ​ຮ້ອນ​' ທີ່​ລະ​ຫັດ​ແມ່ນ​ການ​ນໍາ​ໃຊ້​ຢ່າງ​ຫຼວງ​ຫຼາຍ​ຂອງ​
ເວລາຄອມພິວເຕີ. ເຊັ່ນດຽວກັນ, ເນື່ອງຈາກວ່າ gcov ສະສົມສະຖິຕິໂດຍສາຍ (ຕ່ໍາສຸດ
ຄວາມລະອຽດ), ມັນເຮັດວຽກທີ່ດີທີ່ສຸດກັບຮູບແບບການຂຽນໂປລແກລມທີ່ວາງພຽງແຕ່ຫນຶ່ງຄໍາຖະແຫຼງກ່ຽວກັບແຕ່ລະຄົນ
ສາຍ. ຖ້າທ່ານໃຊ້ macros ສັບສົນທີ່ຂະຫຍາຍໄປສູ່ loops ຫຼືໂຄງສ້າງການຄວບຄຸມອື່ນໆ,
ສະ​ຖິ​ຕິ​ແມ່ນ​ບໍ່​ເປັນ​ປະ​ໂຫຍດ --- ພວກ​ເຂົາ​ເຈົ້າ​ພຽງ​ແຕ່​ລາຍ​ງານ​ກ່ຽວ​ກັບ​ເສັ້ນ​ທີ່​ການ​ໂທ macro​
ປະກົດ. ຖ້າມະຫາພາກທີ່ຊັບຊ້ອນຂອງເຈົ້າເຮັດຕົວຄືກັບຟັງຊັນຕ່າງໆ, ເຈົ້າສາມາດປ່ຽນພວກມັນດ້ວຍແຖວໄດ້
ຫນ້າທີ່ແກ້ໄຂບັນຫານີ້.

gcov ສ້າງ logfile ເອີ້ນວ່າ sourcefile.gcov ເຊິ່ງຊີ້ບອກຈຳນວນເທື່ອຂອງແຕ່ລະແຖວ
ໄຟລ໌ແຫຼ່ງ sourcefile.c ໄດ້​ປະ​ຕິ​ບັດ​. ທ່ານສາມາດນໍາໃຊ້ logfiles ເຫຼົ່ານີ້ພ້ອມກັບ ກປ to
ຊ່ວຍ​ປັບ​ປຸງ​ການ​ປະ​ຕິ​ບັດ​ຂອງ​ໂຄງ​ການ​ຂອງ​ທ່ານ​. ກປ ໃຫ້​ຂໍ້​ມູນ​ກໍາ​ນົດ​ເວ​ລາ​ທີ່​ທ່ານ​
ສາມາດໃຊ້ພ້ອມກັບຂໍ້ມູນທີ່ທ່ານໄດ້ຮັບຈາກ gcov.

gcov ເຮັດວຽກພຽງແຕ່ໃນລະຫັດທີ່ລວບລວມກັບ GCC. ມັນບໍ່ເຂົ້າກັນໄດ້ກັບໂປຣໄຟລ໌ອື່ນໆ
ຫຼືກົນໄກການຄຸ້ມຄອງການທົດສອບ.

OPTIONS

-h
- ຊ່ວຍ
ສະແດງການຊ່ວຍເຫຼືອກ່ຽວກັບການນໍາໃຊ້ gcov (ຕາມມາດຕະຖານຜົນຜະລິດ), ແລະອອກໂດຍບໍ່ມີການດໍາເນີນການໃດໆ
ການປຸງແຕ່ງຕື່ມອີກ.

-v
- ການປ່ຽນແປງ
ສະແດງໃຫ້ເຫັນ gcov ຈໍານວນສະບັບ (ຢູ່ໃນມາດຕະຖານຜົນຜະລິດ), ແລະອອກໂດຍບໍ່ມີການດໍາເນີນການໃດໆ
ການປຸງແຕ່ງຕື່ມອີກ.

-a
--ຕັນທັງໝົດ
ຂຽນຈໍານວນການປະຕິບັດສ່ວນບຸກຄົນສໍາລັບທຸກໆຕັນພື້ນຖານ. ປົກກະຕິຜົນຜະລິດ gcov
ການປະຕິບັດນັບພຽງແຕ່ສໍາລັບຕັນຕົ້ນຕໍຂອງເສັ້ນ. ດ້ວຍທາງເລືອກນີ້, ທ່ານສາມາດເຮັດໄດ້
ກໍານົດວ່າຕັນພາຍໃນເສັ້ນດຽວບໍ່ໄດ້ຖືກປະຕິບັດ.

-b
--ສາຂາ-ຄວາມເປັນໄປໄດ້
ຂຽນຄວາມຖີ່ຂອງສາຂາໃສ່ໄຟລ໌ຜົນຜະລິດ, ແລະຂຽນຂໍ້ມູນສະຫຼຸບສາຂາໄປຫາເອກະສານ
ຜົນຜະລິດມາດຕະຖານ. ຕົວເລືອກນີ້ອະນຸຍາດໃຫ້ທ່ານເບິ່ງວ່າແຕ່ລະສາຂາຢູ່ໃນໂຄງການຂອງທ່ານເລື້ອຍໆສໍ່າໃດ
ໄດ້ຖືກປະຕິບັດ. ສາຂາທີ່ບໍ່ມີເງື່ອນໄຂຈະບໍ່ສະແດງໃຫ້ເຫັນ, ເວັ້ນເສຍແຕ່ວ່າ -u ທາງເລືອກແມ່ນໃຫ້.

-c
--ສາຂາ-ນັບ
ຂຽນຄວາມຖີ່ສາຂາເປັນຈໍານວນສາຂາທີ່ເອົາ, ແທນທີ່ຈະເປັນເປີເຊັນ
ສາຂາທີ່ເອົາມາ.

-n
--no-output
ຢ່າສ້າງ gcov ໄຟລ໌ຜົນຜະລິດ.

-l
--long-file-names
ສ້າງຊື່ໄຟລ໌ຍາວສໍາລັບໄຟລ໌ຕົ້ນສະບັບລວມ. ຕົວຢ່າງ, ຖ້າໄຟລ໌ header xh
ປະກອບມີລະຫັດ, ແລະຖືກລວມຢູ່ໃນໄຟລ໌ ac, ຫຼັງຈາກນັ້ນແລ່ນ gcov ຢູ່ໃນໄຟລ໌ ac
ຈະຜະລິດໄຟລ໌ຜົນຜະລິດທີ່ເອີ້ນວ່າ ac##xhgcov ແທນ​ທີ່ xhgcov. ນີ້ສາມາດເປັນໄດ້
ທີ່ເປັນປະໂຫຍດຖ້າຫາກວ່າ xh ແມ່ນລວມຢູ່ໃນຫຼາຍແຫຼ່ງໄຟລ໌ແລະທ່ານຕ້ອງການເບິ່ງບຸກຄົນ
ການປະກອບສ່ວນ. ຖ້າທ່ານໃຊ້ -p ທາງເລືອກ, ທັງຊື່ໄຟລ໌ລວມແລະລວມ
ຈະເປັນຊື່ເສັ້ນທາງທີ່ສົມບູນ.

-p
-- ຮັກສາເສັ້ນທາງ
ຮັກສາຂໍ້ມູນເສັ້ນທາງທີ່ສົມບູນໃນຊື່ທີ່ສ້າງຂຶ້ນ .gcov ໄຟລ໌. ໂດຍບໍ່ມີການ
ທາງເລືອກນີ້, ພຽງແຕ່ອົງປະກອບຊື່ໄຟລ໌ຖືກນໍາໃຊ້. ດ້ວຍຕົວເລືອກນີ້, ທຸກລາຍການ
ຖືກນໍາໃຊ້, ກັບ / ຕົວອັກສອນແປເປັນ # ຕົວລະຄອນ, . ເອົາອົງປະກອບໄດເລກະທໍລີອອກ
ແລະ unremovable .. ອົງປະກອບປ່ຽນຊື່ເປັນ ^. ນີ້ເປັນປະໂຫຍດຖ້າແຫຼ່ງໄຟລ໌ຢູ່ໃນ
ຫຼາຍໄດເລກະທໍລີທີ່ແຕກຕ່າງກັນ.

-r
--ພີ່ນ້ອງເທົ່ານັ້ນ
ຂໍ້ມູນອອກພຽງແຕ່ກ່ຽວກັບໄຟລ໌ຕົ້ນສະບັບທີ່ມີຊື່ເສັ້ນທາງທີ່ກ່ຽວຂ້ອງ (ຫຼັງຈາກແຫຼ່ງ
prefix elision). ເສັ້ນທາງຢ່າງແທ້ຈິງແມ່ນປົກກະຕິແລ້ວໄຟລ໌ສ່ວນຫົວຂອງລະບົບແລະການຄຸ້ມຄອງໃດໆ
ຟັງຊັນ inline ຢູ່ໃນນັ້ນປົກກະຕິບໍ່ຫນ້າສົນໃຈ.

-f
--function-ສະຫຼຸບ
ຜົນສະຫຼຸບສໍາລັບແຕ່ລະຫນ້າທີ່ນອກຈາກການສະຫຼຸບລະດັບໄຟລ໌.

-o ໄດເລກະທໍລີ|ໄຟລ໌
--object-directory ລະບົບ
--object-file ເອກະສານ
ລະບຸໄດເລກະທໍລີທີ່ມີໄຟລ໌ຂໍ້ມູນ gcov, ຫຼືຊື່ເສັ້ນທາງວັດຖຸ.
ໄດ້ .gcno, ແລະ .gcda ໄຟລ໌ຂໍ້ມູນຖືກຄົ້ນຫາໂດຍໃຊ້ຕົວເລືອກນີ້. ຖ້າໄດເລກະທໍລີແມ່ນ
ລະບຸໄວ້, ໄຟລ໌ຂໍ້ມູນຢູ່ໃນໄດເລກະທໍລີນັ້ນ ແລະຕັ້ງຊື່ຕາມຊື່ໄຟລ໌ທີ່ປ້ອນເຂົ້າ,
ໂດຍບໍ່ມີການຂະຫຍາຍຂອງມັນ. ຖ້າໄຟລ໌ຖືກລະບຸຢູ່ທີ່ນີ້, ໄຟລ໌ຂໍ້ມູນຈະຖືກຕັ້ງຊື່ຕາມ
ໄຟລ໌ນັ້ນ, ໂດຍບໍ່ມີການຂະຫຍາຍຂອງມັນ.

-s ລະບົບ
--source-prefix ລະບົບ
ຄໍານໍາຫນ້າສໍາລັບຊື່ໄຟລ໌ຕົ້ນສະບັບທີ່ຈະເອົາອອກໃນເວລາທີ່ການສ້າງໄຟລ໌ການຄຸ້ມຄອງຜົນຜະລິດ.
ຕົວເລືອກນີ້ແມ່ນເປັນປະໂຫຍດໃນເວລາທີ່ສ້າງຢູ່ໃນໄດເລກະທໍລີແຍກຕ່າງຫາກ, ແລະຊື່ເສັ້ນທາງໄປຫາ
ໄດເລກະທໍລີແຫຼ່ງບໍ່ຕ້ອງການໃນເວລາທີ່ກໍານົດຊື່ໄຟລ໌ຜົນຜະລິດ. ໃຫ້ສັງເກດວ່ານີ້
ການກວດຫາຄໍານໍາຫນ້າແມ່ນຖືກນໍາໃຊ້ກ່ອນທີ່ຈະກໍານົດວ່າໄຟລ໌ແຫຼ່ງແມ່ນຢ່າງແທ້ຈິງ.

-u
--ສາຂາທີ່ບໍ່ມີເງື່ອນໄຂ
ເມື່ອມີຄວາມເປັນໄປໄດ້ຂອງສາຂາ, ໃຫ້ລວມເອົາສາຂາທີ່ບໍ່ມີເງື່ອນໄຂ.
ສາຂາທີ່ບໍ່ມີເງື່ອນໄຂແມ່ນປົກກະຕິບໍ່ຫນ້າສົນໃຈ.

-d
--ສະແດງ-ຄວາມຄືບໜ້າ
ສະແດງຄວາມຄືບຫນ້າຂອງຜົນຜະລິດມາດຕະຖານ.

-i
--intermediate-format
ສົ່ງອອກໄຟລ໌ gcov ໃນຮູບແບບຂໍ້ຄວາມລະດັບປານກາງທີ່ງ່າຍຕໍ່ການວິເຄາະທີ່ສາມາດໃຊ້ໄດ້ໂດຍ lcov
ຫຼືເຄື່ອງມືອື່ນໆ. ຜົນຜະລິດແມ່ນອັນດຽວ .gcov ໄຟລ໌ຕໍ່ .gcda ໄຟລ໌. ບໍ່ມີລະຫັດແຫຼ່ງ
ຕ້ອງການ.

ຮູບແບບຂອງລະດັບປານກາງ .gcov ໄຟລ໌ແມ່ນຂໍ້ຄວາມທຳມະດາທີ່ມີໜຶ່ງລາຍການຕໍ່ແຖວ

ໄຟລ໌:
ຟັງຊັນ: , ,
ຈຳນວນ: ,
ສາຂາ: ,

ບ່ອນທີ່ ແມ່ນ
notexec (ສາຂາບໍ່ຖືກປະຕິບັດ)
ໄດ້​ຮັບ (ສາຂາ​ປະ​ຕິ​ບັດ​ແລະ​ປະ​ຕິ​ບັດ​)
nottaken (ສາຂາຖືກປະຕິບັດ, ແຕ່ບໍ່ໄດ້ເອົາ)

ສາມາດມີຫຼາຍ ລາຍການຢູ່ໃນ gcov ລະດັບປານກາງ
ໄຟລ໌. ລາຍການທັງໝົດຕໍ່ໄປນີ້ ກ ກ່ຽວຂ້ອງກັບໄຟລ໌ແຫຼ່ງນັ້ນ
ຈົນກ່ວາຕໍ່ໄປ ເຂົ້າ.

ນີ້ແມ່ນຕົວຢ່າງເມື່ອ -i ແມ່ນໃຊ້ຮ່ວມກັບ -b ຕົວເລືອກ:

ໄຟລ໌:array.cc
ຟັງຊັ່ນ:11,1,_Z3sumRKSt6vectorIPiSaIS0_EE
ຫນ້າ​ທີ່​: 22,1​, XNUMX​, ຕົ້ນ​ຕໍ​
ຈຳນວນ: 11,1
ຈຳນວນ: 12,1
ຈຳນວນ: 14,1
ສາຂາ: 14, ເອົາ
ຈຳນວນ: 26,1
ສາ​ຂາ​: 28​, nottaken

-m
--demangled-ຊື່
ສະແດງຊື່ຟັງຊັນ demangled ໃນຜົນຜະລິດ. ຄ່າເລີ່ມຕົ້ນແມ່ນເພື່ອສະແດງຫນ້າທີ່ mangled
ຊື່.

gcov ຄວນຈະດໍາເນີນການກັບໄດເລກະທໍລີປະຈຸບັນຄືກັນກັບວ່າໃນເວລາທີ່ທ່ານ invoked the
ສັງລວມ. ຖ້າບໍ່ດັ່ງນັ້ນມັນຈະບໍ່ສາມາດຊອກຫາໄຟລ໌ຕົ້ນສະບັບໄດ້. gcov ຜະລິດໄຟລ໌
ເອີ້ນວ່າ mangledname.gcov ໃນ​ລະ​ບົບ​ປະ​ຈຸ​ບັນ​. ເຫຼົ່ານີ້ປະກອບດ້ວຍຂໍ້ມູນການຄຸ້ມຄອງ
ຂອງໄຟລ໌ແຫຼ່ງທີ່ເຂົາເຈົ້າສອດຄ້ອງກັບ. ຫນຶ່ງ .gcov ໄຟລ໌ແມ່ນຜະລິດສໍາລັບແຕ່ລະແຫຼ່ງ (ຫຼື
header) ໄຟລ໌ທີ່ມີລະຫັດ, ເຊິ່ງໄດ້ຖືກລວບລວມເພື່ອຜະລິດໄຟລ໌ຂໍ້ມູນ. ໄດ້
ຊື່ mangled ສ່ວນຫນຶ່ງຂອງຊື່ໄຟລ໌ຜົນຜະລິດແມ່ນປົກກະຕິແລ້ວພຽງແຕ່ຊື່ໄຟລ໌ແຫຼ່ງ, ແຕ່ສາມາດເຮັດໄດ້
ບາງສິ່ງບາງຢ່າງທີ່ສັບສົນຫຼາຍຖ້າຫາກວ່າ -l or -p ທາງເລືອກແມ່ນໃຫ້. ອ້າງເຖິງທາງເລືອກເຫຼົ່ານັ້ນ
ສໍາລັບລາຍລະອຽດ.

ຖ້າເຈົ້າຮຽກຮ້ອງ gcov ດ້ວຍໄຟລ໌ປ້ອນຂໍ້ມູນຫຼາຍອັນ, ການປະກອບສ່ວນຈາກແຕ່ລະໄຟລ໌ປ້ອນຂໍ້ມູນແມ່ນ
ສະຫຼຸບ. ໂດຍປົກກະຕິທ່ານຈະເອີ້ນມັນດ້ວຍລາຍຊື່ໄຟລ໌ດຽວກັນກັບການເຊື່ອມຕໍ່ສຸດທ້າຍຂອງ
ການ​ປະ​ຕິ​ບັດ​ຂອງ​ທ່ານ​.

ໄດ້ .gcov ໄຟລ໌ປະກອບດ້ວຍ : ຊ່ອງຂໍ້ມູນທີ່ແຍກອອກພ້ອມກັບລະຫັດແຫຼ່ງໂຄງການ. ຮູບແບບ
is

: :

ຂໍ້ມູນບລັອກເພີ່ມເຕີມອາດຈະປະສົບຜົນສໍາເລັດໃນແຕ່ລະເສັ້ນ, ເມື່ອຖືກຮ້ອງຂໍໂດຍທາງເລືອກແຖວຄໍາສັ່ງ.
ໄດ້ execution_count is - ສໍາລັບສາຍທີ່ບໍ່ມີລະຫັດ. ເສັ້ນທີ່ບໍ່ໄດ້ປະຕິບັດແມ່ນຫມາຍ #####
or ====, ຂຶ້ນກັບວ່າພວກເຂົາສາມາດບັນລຸໄດ້ໂດຍເສັ້ນທາງທີ່ບໍ່ມີຂໍ້ຍົກເວັ້ນຫຼືພຽງແຕ່
ເສັ້ນທາງພິເສດເຊັ່ນ C++ exception handlers, ຕາມລໍາດັບ.

ບາງສາຍຂໍ້ມູນໃນຕອນເລີ່ມຕົ້ນມີ line_number ຂອງສູນ. ສາຍ preamble ເຫຼົ່ານີ້ແມ່ນ
ຂອງແບບຟອມ

-:0: :

ຄໍາສັ່ງແລະຈໍານວນຂອງສາຍ preamble ເຫຼົ່ານີ້ຈະໄດ້ຮັບການເພີ່ມຂຶ້ນເປັນ gcov ການພັດທະນາ
ຄວາມຄືບຫນ້າ --- ຢ່າອີງໃສ່ພວກມັນທີ່ຍັງຄົງບໍ່ປ່ຽນແປງ. ໃຊ້ ໂຄດ​ຄໍາ​ສັ່ງ ເພື່ອຊອກຫາສະເພາະ
ເສັ້ນ preamble.

ຂໍ້ມູນບລັອກເພີ່ມເຕີມແມ່ນຂອງແບບຟອມ



ໄດ້ ຂໍ້ມູນຂ່າວສານ ແມ່ນມະນຸດສາມາດອ່ານໄດ້, ແຕ່ຖືກອອກແບບໃຫ້ງ່າຍດາຍພຽງພໍສໍາລັບການວິເຄາະເຄື່ອງຈັກ
ເຊັ່ນດຽວກັນ.

ເມື່ອອັດຕາສ່ວນການພິມ, 0% ແລະ 100% ແມ່ນພິມເມື່ອມີຄ່າເທົ່ານັ້ນ ຢ່າງ​ແນ່​ນອນ 0% ແລະ
100% ຕາມລໍາດັບ. ຄ່າອື່ນໆທີ່ຕາມທຳມະດາຈະຖືກປັດເປັນ 0% ຫຼື 100% ແມ່ນ
ແທນທີ່ຈະພິມເປັນຄ່າທີ່ບໍ່ແມ່ນຂອບເຂດທີ່ໃກ້ທີ່ສຸດ.

ເມື່ອນໍາໃຊ້ gcov, ກ່ອນອື່ນທ່ານຕ້ອງລວບລວມໂປຼແກຼມຂອງທ່ານດ້ວຍສອງທາງເລືອກ GCC ພິເສດ:
-fprofile-arcs -ftest-ການ​ຄຸ້ມ​ຄອງ​. ນີ້ບອກ compiler ເພື່ອສ້າງເພີ່ມເຕີມ
ຂໍ້​ມູນ​ທີ່​ຈໍາ​ເປັນ​ໂດຍ gcov (ໂດຍ​ພື້ນ​ຖານ​ເປັນ​ເສັ້ນ​ສະ​ແດງ​ຂອງ​ໂຄງ​ການ​) ແລະ​ຍັງ​ປະ​ກອບ​ມີ​
ລະຫັດເພີ່ມເຕີມໃນໄຟລ໌ວັດຖຸສໍາລັບການສ້າງຂໍ້ມູນໂປຣໄຟລ໌ເພີ່ມເຕີມທີ່ຈໍາເປັນ
ໂດຍ gcov. ໄຟລ໌ເພີ່ມເຕີມເຫຼົ່ານີ້ຖືກຈັດໃສ່ໃນໄດເລກະທໍລີທີ່ໄຟລ໌ວັດຖຸຢູ່
ຕັ້ງຢູ່.

ການດໍາເນີນການໂຄງການຈະເຮັດໃຫ້ຜົນຜະລິດໂປຣໄຟລ໌ຈະຖືກສ້າງຂຶ້ນ. ສໍາລັບແຕ່ລະໄຟລ໌ແຫຼ່ງ
ລວບລວມດ້ວຍ -fprofile-arcs, ມາພ້ອມກັບ .gcda ໄຟລ໌ຈະຖືກຈັດໃສ່ໃນໄຟລ໌ວັດຖຸ
ລະບົບ.

ເຮັດວຽກ gcov ກັບຊື່ໄຟລ໌ຕົ້ນສະບັບຂອງໂຄງການຂອງທ່ານເປັນ arguments ໃນປັດຈຸບັນຈະຜະລິດລາຍການ
ຂອງລະຫັດພ້ອມກັບຄວາມຖີ່ຂອງການປະຕິບັດສໍາລັບແຕ່ລະເສັ້ນ. ຕົວຢ່າງ, ຖ້າໂຄງການຂອງທ່ານ
ຖືກເອີ້ນວ່າ tmp.c, ນີ້ແມ່ນສິ່ງທີ່ທ່ານເຫັນໃນເວລາທີ່ທ່ານໃຊ້ພື້ນຖານ gcov ສິ່ງອໍານວຍຄວາມສະດວກ:

$ gcc -fprofile-arcs -ftest-coverage tmp.c
$ a.out
$ gcov tmp.c
90.00% ຂອງ 10 ແຖວແຫຼ່ງທີ່ປະຕິບັດຢູ່ໃນໄຟລ໌ tmp.c
ການສ້າງ tmp.c.gcov.

ໄຟລ໌ tmp.c.gcov ປະກອບດ້ວຍຜົນຜະລິດຈາກ gcovທີ່ຢູ່ ນີ້ແມ່ນຕົວຢ່າງ:

-: 0:ທີ່ມາ: tmp.c
-: 0:ກຣາບ:tmp.gcno
-: 0:Data:tmp.gcda
-: 0:ແລ່ນ:1
-: 0:ລາຍການ:1
-: 1: #ລວມ
- : 2:
-: 3: int main (void)
1:4:{
1: 5: int i, ທັງຫມົດ;
- : 6:
1:7: ທັງໝົດ = 0;
- : 8:
11: 9: ສໍາລັບ (i = 0; i < 10; i++)
10: 10: ທັງໝົດ += i;
- : 11:
1: 12: ຖ້າ (ທັງຫມົດ != 45)
#####: 13: printf ("ຄວາມລົ້ມເຫຼວ\n");
- : 14 : ອື່ນ
1: 15: printf ("ຄວາມສໍາເລັດ\n");
1: 16: ກັບຄືນ 0;
-: 17:}

ເມື່ອທ່ານໃຊ້ -a ທາງ​ເລືອກ​, ທ່ານ​ຈະ​ໄດ້​ຮັບ​ການ​ນັບ block ຂອງ​ບຸກ​ຄົນ​, ແລະ​ຜົນ​ຜະ​ລິດ​ເບິ່ງ​
ເຊັ່ນນີ້:

-: 0:ທີ່ມາ: tmp.c
-: 0:ກຣາບ:tmp.gcno
-: 0:Data:tmp.gcda
-: 0:ແລ່ນ:1
-: 0:ລາຍການ:1
-: 1: #ລວມ
- : 2:
-: 3: int main (void)
1:4:{
1:4-ຕັນ 0
1: 5: int i, ທັງຫມົດ;
- : 6:
1:7: ທັງໝົດ = 0;
- : 8:
11: 9: ສໍາລັບ (i = 0; i < 10; i++)
11:9-ຕັນ 0
10: 10: ທັງໝົດ += i;
10:10-ຕັນ 0
- : 11:
1: 12: ຖ້າ (ທັງຫມົດ != 45)
1:12-ຕັນ 0
#####: 13: printf ("ຄວາມລົ້ມເຫຼວ\n");
$$$$$: 13-block 0
- : 14 : ອື່ນ
1: 15: printf ("ຄວາມສໍາເລັດ\n");
1:15-ຕັນ 0
1: 16: ກັບຄືນ 0;
1:16-ຕັນ 0
-: 17:}

ໃນ​ຮູບ​ແບບ​ນີ້​, ແຕ່​ລະ​ຕັນ​ຂັ້ນ​ພື້ນ​ຖານ​ແມ່ນ​ສະ​ແດງ​ໃຫ້​ເຫັນ​ພຽງ​ແຕ່​ຢູ່​ໃນ​ແຖວ​ດຽວ - ເສັ້ນ​ສຸດ​ທ້າຍ​ຂອງ​ຕັນ​. ກ
ຕັນຫຼາຍແຖວຈະປະກອບສ່ວນພຽງແຕ່ການນັບການປະຕິບັດຂອງແຖວສຸດທ້າຍນັ້ນ, ແລະອື່ນໆ
ເສັ້ນຈະບໍ່ຖືກສະແດງໃຫ້ເຫັນວ່າມີລະຫັດ, ເວັ້ນເສຍແຕ່ວ່າຕັນທີ່ຜ່ານມາຈະສິ້ນສຸດໃນແຖວເຫຼົ່ານັ້ນ. ໄດ້
ຈຳນວນການປະຕິບັດທັງໝົດຂອງເສັ້ນແມ່ນສະແດງ ແລະສາຍຕໍ່ໆມາຈະສະແດງຈຳນວນການປະຕິບັດ
ສໍາລັບຕັນສ່ວນບຸກຄົນທີ່ສິ້ນສຸດໃນແຖວນັ້ນ. ຫຼັງຈາກແຕ່ລະຕັນ, ສາຂາແລະການໂທນັບ
ຂອງຕັນຈະຖືກສະແດງໃຫ້ເຫັນ, ຖ້າຫາກວ່າ -b ທາງເລືອກແມ່ນໃຫ້.

ເນື່ອງຈາກວິທີການ GCC ໂທຫາ, ຈໍານວນການໂທສາມາດສະແດງໄດ້ຫຼັງຈາກສາຍທີ່ບໍ່ມີ
ທ່ອນໄມ້ສ່ວນບຸກຄົນ. ດັ່ງທີ່ທ່ານສາມາດເຫັນໄດ້, ເສັ້ນ 13 ມີຕັນພື້ນຖານທີ່ບໍ່ໄດ້ຖືກປະຕິບັດ.

ເມື່ອທ່ານໃຊ້ -b ທາງ​ເລືອກ​, ຜົນ​ຜະ​ລິດ​ຂອງ​ທ່ານ​ເບິ່ງ​ຄື​ນີ້​:

$ gcov -b tmp.c
90.00% ຂອງ 10 ແຖວແຫຼ່ງທີ່ປະຕິບັດຢູ່ໃນໄຟລ໌ tmp.c
80.00% ຂອງ 5 ສາຂາທີ່ຖືກປະຕິບັດໃນໄຟລ໌ tmp.c
80.00% ຂອງ 5 ສາຂາປະຕິບັດຢ່າງຫນ້ອຍຫນຶ່ງຄັ້ງໃນໄຟລ໌ tmp.c
50.00% ຂອງ 2 ສາຍຖືກປະຕິບັດໃນໄຟລ໌ tmp.c
ການສ້າງ tmp.c.gcov.

ນີ້ແມ່ນຕົວຢ່າງຂອງຜົນໄດ້ຮັບ tmp.c.gcov file:

-: 0:ທີ່ມາ: tmp.c
-: 0:ກຣາບ:tmp.gcno
-: 0:Data:tmp.gcda
-: 0:ແລ່ນ:1
-: 0:ລາຍການ:1
-: 1: #ລວມ
- : 2:
-: 3: int main (void)
ຟັງຊັນຫຼັກເອີ້ນວ່າ 1 ສົ່ງຄືນ 1 ບລ໋ອກປະຕິບັດໄດ້ 75%
1:4:{
1: 5: int i, ທັງຫມົດ;
- : 6:
1:7: ທັງໝົດ = 0;
- : 8:
11: 9: ສໍາລັບ (i = 0; i < 10; i++)
ສາຂາ 0 ປະຕິບັດໄດ້ 91% (ຫຼຸດ)
ສາຂາ 1 ເອົາ 9%
10: 10: ທັງໝົດ += i;
- : 11:
1: 12: ຖ້າ (ທັງຫມົດ != 45)
ສາຂາ 0 ປະຕິບັດໄດ້ 0% (ຫຼຸດ)
ສາຂາ 1 ເອົາ 100%
#####: 13: printf ("ຄວາມລົ້ມເຫຼວ\n");
ໂທ 0 ບໍ່ເຄີຍຖືກປະຕິບັດ
- : 14 : ອື່ນ
1: 15: printf ("ຄວາມສໍາເລັດ\n");
ໂທ 0 ໂທ 1 ສົ່ງຄືນ 100%
1: 16: ກັບຄືນ 0;
-: 17:}

ສໍາລັບແຕ່ລະຟັງຊັນ, ເສັ້ນຖືກພິມສະແດງວ່າມີຈໍານວນຄັ້ງທີ່ຟັງຊັນຖືກເອີ້ນ, ແນວໃດ
ຫຼາຍຄັ້ງທີ່ມັນກັບຄືນມາແລະອັດຕາສ່ວນຂອງບລັອກຂອງຫນ້າທີ່ຖືກປະຕິບັດ.

ສໍາລັບແຕ່ລະບລັອກພື້ນຖານ, ເສັ້ນຖືກພິມອອກຫຼັງຈາກແຖວສຸດທ້າຍຂອງບລັອກພື້ນຖານທີ່ອະທິບາຍ
ສາຂາຫຼືໂທຫາທີ່ສິ້ນສຸດຕັນພື້ນຖານ. ສາມາດມີຫຼາຍສາຂາ ແລະ ໂທ
ລະບຸໄວ້ສໍາລັບແຖວແຫຼ່ງດຽວຖ້າມີຫຼາຍໆບລັອກພື້ນຖານທີ່ສິ້ນສຸດໃນແຖວນັ້ນ.
ໃນ​ກໍ​ລະ​ນີ​ນີ້​, ສາ​ຂາ​ແລະ​ການ​ໂທ​ແມ່ນ​ແຕ່​ລະ​ຄົນ​ໄດ້​ຮັບ​ຈໍາ​ນວນ​. ບໍ່ມີວິທີທີ່ງ່າຍດາຍທີ່ຈະ
ແຜນທີ່ສາຂາເຫຼົ່ານີ້ແລະໂທຫາການກໍ່ສ້າງແຫຼ່ງ. ໂດຍທົ່ວໄປ, ເຖິງແມ່ນວ່າ, ຕ່ໍາສຸດ
ສາຂາທີ່ມີຕົວເລກຫຼືການໂທຈະກົງກັນກັບການກໍ່ສ້າງທາງຊ້າຍສຸດຂອງສາຍແຫຼ່ງ.

ສໍາລັບສາຂາ, ຖ້າມັນຖືກປະຕິບັດຢ່າງຫນ້ອຍຫນຶ່ງຄັ້ງ, ຫຼັງຈາກນັ້ນອັດຕາສ່ວນທີ່ຊີ້ໃຫ້ເຫັນເຖິງຈໍານວນ
ຄັ້ງທີ່ສາຂາໄດ້ຖືກປະຕິບັດແບ່ງອອກດ້ວຍຈໍານວນຂອງເວລາທີ່ສາຂາໄດ້ຖືກປະຕິບັດຈະເປັນ
ພິມ. ຖ້າບໍ່ດັ່ງນັ້ນ, ຂໍ້ຄວາມ "ບໍ່ເຄີຍປະຕິບັດ" ຖືກພິມອອກ.

ສໍາ​ລັບ​ການ​ໂທ​, ຖ້າ​ຫາກ​ວ່າ​ມັນ​ໄດ້​ຖືກ​ປະ​ຕິ​ບັດ​ຢ່າງ​ຫນ້ອຍ​ຫນຶ່ງ​ຄັ້ງ​, ຫຼັງ​ຈາກ​ນັ້ນ​ອັດ​ຕາ​ສ່ວນ​ທີ່​ຊີ້​ບອກ​ຈໍາ​ນວນ​ຂອງ​
ເວລາການໂທກັບຄືນມາແບ່ງດ້ວຍຈໍານວນເວລາທີ່ການໂທຖືກປະຕິບັດ
ພິມ. ນີ້ປົກກະຕິແລ້ວຈະເປັນ 100%, ແຕ່ອາດຈະເປັນຫນ້ອຍສໍາລັບຫນ້າທີ່ເອີ້ນວ່າ "ອອກ" ຫຼື
"longjmp", ແລະດັ່ງນັ້ນອາດຈະບໍ່ກັບຄືນມາທຸກຄັ້ງທີ່ພວກເຂົາຖືກເອີ້ນ.

ຈໍານວນການປະຕິບັດແມ່ນສະສົມ. ຖ້າຫາກວ່າໂຄງການຕົວຢ່າງໄດ້ຖືກປະຕິບັດອີກເທື່ອຫນຶ່ງໂດຍບໍ່ມີການ
ການຖອນ .gcda ໄຟລ໌, ການນັບຈໍານວນຄັ້ງຂອງແຕ່ລະແຖວໃນແຫຼ່ງແມ່ນ
ການປະຕິບັດຈະຖືກເພີ່ມເຂົ້າໃນຜົນໄດ້ຮັບຂອງການແລ່ນທີ່ຜ່ານມາ. ອັນນີ້ອາດຈະເປັນປະໂຫຍດ
ໃນຫຼາຍວິທີ. ສໍາລັບຕົວຢ່າງ, ມັນສາມາດຖືກນໍາໃຊ້ເພື່ອສະສົມຂໍ້ມູນຫຼາຍກວ່າຈໍານວນ
ໂປຣແກມເຮັດວຽກເປັນສ່ວນໜຶ່ງຂອງຊຸດການຢັ້ງຢືນການທົດສອບ, ຫຼືເພື່ອໃຫ້ຄວາມຖືກຕ້ອງໃນໄລຍະຍາວກວ່າ
ຂໍ້​ມູນ​ໃນ​ໄລ​ຍະ​ຈໍາ​ນວນ​ຫຼາຍ​ຂອງ​ໂຄງ​ການ​ທີ່​ດໍາ​ເນີນ​ການ​.

ຂໍ້ມູນຢູ່ໃນ .gcda ໄຟລ໌ຖືກບັນທຶກທັນທີກ່ອນທີ່ໂຄງການຈະອອກ. ສໍາລັບແຕ່ລະຄົນ
ໄຟລ໌ແຫຼ່ງທີ່ລວບລວມດ້ວຍ -fprofile-arcs, ລະຫັດ profileing ທໍາອິດພະຍາຍາມອ່ານຢູ່ໃນ
ມີຢູ່ແລ້ວ .gcda ໄຟລ໌; ຖ້າ​ຫາກ​ວ່າ​ໄຟລ​໌​ບໍ່​ກົງ​ກັບ​ການ​ປະ​ຕິ​ບັດ (ທີ່​ແຕກ​ຕ່າງ​ກັນ​ຂອງ​ຈໍາ​ນວນ​ພື້ນ​ຖານ​
block counts) ມັນຈະບໍ່ສົນໃຈເນື້ອໃນຂອງໄຟລ໌. ຫຼັງຈາກນັ້ນ, ມັນເພີ່ມເຕີມໃນການປະຕິບັດໃຫມ່
ນັບແລະສຸດທ້າຍຂຽນຂໍ້ມູນໃສ່ໄຟລ໌.

ການນໍາໃຊ້ gcov ກັບ GCC ທີ່ດີທີ່ສຸດ

ຖ້າທ່ານວາງແຜນທີ່ຈະໃຊ້ gcov ເພື່ອຊ່ວຍປັບປຸງລະຫັດຂອງທ່ານ, ກ່ອນອື່ນ ໝົດ ທ່ານຕ້ອງລວບລວມໂປແກຼມຂອງທ່ານ
ດ້ວຍສອງທາງເລືອກ GCC ພິເສດ: -fprofile-arcs -ftest-ການ​ຄຸ້ມ​ຄອງ​. ນອກ​ຈາກ​ນັ້ນ​, ທ່ານ​ສາ​ມາດ​ເຮັດ​ໄດ້​
ໃຊ້ທາງເລືອກ GCC ອື່ນໆ; ແຕ່ຖ້າທ່ານຕ້ອງການພິສູດວ່າທຸກໆເສັ້ນດຽວໃນໂຄງການຂອງທ່ານ
ໄດ້ຖືກປະຕິບັດ, ທ່ານບໍ່ຄວນລວບລວມກັບການເພີ່ມປະສິດທິພາບໃນເວລາດຽວກັນ. ໃນບາງເຄື່ອງ
optimizer ສາມາດລົບລ້າງບາງສາຍລະຫັດງ່າຍໆໂດຍການລວມພວກມັນກັບສາຍອື່ນໆ.
ຕົວຢ່າງ, ລະຫັດແບບນີ້:

ຖ້າ (a != b)
c = 1;
ອື່ນ
c = 0;

ສາມາດລວບລວມເປັນຄໍາແນະນໍາຫນຶ່ງໃນບາງເຄື່ອງຈັກ. ໃນກໍລະນີນີ້, ບໍ່ມີທາງສໍາລັບ
gcov ເພື່ອຄິດໄລ່ຈໍານວນການປະຕິບັດແຍກຕ່າງຫາກສໍາລັບແຕ່ລະເສັ້ນເພາະວ່າບໍ່ມີແຍກຕ່າງຫາກ
ລະຫັດສໍາລັບແຕ່ລະແຖວ. ເພາະ​ສະ​ນັ້ນ​ gcov ຜົນຜະລິດເບິ່ງຄືວ່ານີ້ຖ້າທ່ານລວບລວມໂຄງການ
ດ້ວຍການເພີ່ມປະສິດທິພາບ:

100: 12: ຖ້າ (a != b)
100 : 13 : ຄ = 1 ;
100: 14: ອື່ນ
100 : 15 : ຄ = 0 ;

ຜົນໄດ້ຮັບສະແດງໃຫ້ເຫັນວ່າລະຫັດບລັອກນີ້, ປະສົມປະສານໂດຍການເພີ່ມປະສິດທິພາບ, ປະຕິບັດ 100 ເທື່ອ.
ໃນຄວາມຫມາຍຫນຶ່ງຜົນໄດ້ຮັບນີ້ແມ່ນຖືກຕ້ອງ, ເພາະວ່າມີພຽງແຕ່ຄໍາແນະນໍາຫນຶ່ງທີ່ເປັນຕົວແທນ
ທັງສີ່ສາຍນີ້. ຢ່າງໃດກໍ່ຕາມ, ຜົນຜະລິດບໍ່ໄດ້ລະບຸວ່າຜົນໄດ້ຮັບຈໍານວນເທົ່າໃດ
ແມ່ນ 0 ແລະ ຜົນໄດ້ຮັບແມ່ນ 1 ເທົ່າໃດ.

ຟັງຊັນ inlineable ສາມາດສ້າງຈໍານວນເສັ້ນທີ່ບໍ່ຄາດຄິດ. ການນັບສາຍແມ່ນສະແດງໃຫ້ເຫັນສໍາລັບ
ລະຫັດແຫຼ່ງຂອງຟັງຊັນ inlineable, ແຕ່ສິ່ງທີ່ສະແດງແມ່ນຂຶ້ນກັບບ່ອນທີ່ຟັງຊັນ
inlined, ຫຼືຖ້າຫາກວ່າມັນບໍ່ໄດ້ຖືກ inlined ທັງຫມົດ.

ຖ້າຟັງຊັນບໍ່ຢູ່ໃນແຖວ, compiler ຈະຕ້ອງປ່ອຍສໍາເນົາອອກຈາກເສັ້ນ
ຟັງຊັນ, ໃນໄຟລ໌ວັດຖຸທີ່ຕ້ອງການມັນ. ຖ້າ ໄຟລ໌A.o ແລະ ໄຟລ໌B.o ທັງສອງປະກອບດ້ວຍອອກຈາກ
ອົງການຈັດຕັ້ງສາຍຂອງຫນ້າທີ່ inlineable ໂດຍສະເພາະ, ພວກເຂົາເຈົ້າທັງສອງຍັງຈະມີການຄຸ້ມຄອງ
ນັບສໍາລັບຫນ້າທີ່ນັ້ນ. ເມື່ອ​ໃດ​ ໄຟລ໌A.o ແລະ ໄຟລ໌B.o ເຊື່ອມຕໍ່ກັນ, ຕົວເຊື່ອມຕໍ່ຈະ,
ໃນຫຼາຍລະບົບ, ເລືອກເອົາຫນຶ່ງໃນອົງການຈັດຕັ້ງທີ່ຢູ່ນອກສາຍສໍາລັບການໂທທັງຫມົດໄປຫາຫນ້າທີ່ນັ້ນ,
ແລະເອົາອອກ ຫຼືບໍ່ສົນໃຈອັນອື່ນ. ໂຊກບໍ່ດີ, ມັນຈະບໍ່ເອົາເຄື່ອງນັບການປົກຄຸມອອກ
ສໍາລັບຮ່າງກາຍຂອງຫນ້າທີ່ບໍ່ໄດ້ໃຊ້. ເພາະສະນັ້ນ, ໃນເວລາທີ່ເຄື່ອງມື, ທັງຫມົດຍົກເວັ້ນການນໍາໃຊ້ຫນຶ່ງຂອງຫນ້າທີ່ນັ້ນ
ຈະສະແດງການນັບສູນ.

ຖ້າຟັງຊັນແມ່ນ inlined ໃນຫຼາຍສະຖານທີ່, ໂຄງສ້າງ block ໃນແຕ່ລະສະຖານທີ່ອາດຈະ
ບໍ່ຄືກັນ. ຕົວຢ່າງ, ເງື່ອນໄຂໃນປັດຈຸບັນອາດຈະສາມາດຄິດໄລ່ໄດ້ໃນເວລາລວບລວມ
ບາງຕົວຢ່າງ. ເນື່ອງຈາກວ່າການຄຸ້ມຄອງການນໍາໃຊ້ທັງຫມົດຂອງຟັງຊັນ inline ຈະສະແດງໃຫ້ເຫັນ
ສໍາລັບສາຍແຫຼ່ງດຽວກັນ, ເສັ້ນນັບດ້ວຍຕົນເອງອາດຈະເບິ່ງຄືວ່າບໍ່ສອດຄ່ອງ.

ແອັບພລິເຄຊັນທີ່ໃຊ້ເວລາດົນນານສາມາດໃຊ້ "_gcov_reset" ແລະ "_gcov_dump" ສິ່ງອໍານວຍຄວາມສະດວກເພື່ອ
ຈໍາ​ກັດ​ການ​ເກັບ​ກໍາ​ຂໍ້​ມູນ​ກ່ຽວ​ກັບ​ພາກ​ພື້ນ​ຂອງ​ໂຄງ​ການ​ທີ່​ສົນ​ໃຈ​. ກຳລັງໂທຫາ "_gcov_reset(void)"
ຈະລຶບລ້າງຕົວນັບໂປຣໄຟລ໌ທັງໝົດເປັນສູນ, ແລະການໂທຫາ "_gcov_dump(void)" ຈະເຮັດໃຫ້
ຂໍ້​ມູນ​ຂ່າວ​ສານ​ທີ່​ເກັບ​ກໍາ​ຢູ່​ໃນ​ຈຸດ​ທີ່​ຈະ​ຖືກ dumped​ .gcda ໄຟລ໌ຜົນຜະລິດ.

ໃຊ້ alpha-linux-gnu-gcov-5 ອອນລາຍໂດຍໃຊ້ການບໍລິການ onworks.net