ນີ້ແມ່ນຄໍາສັ່ງ aarch64-linux-gnu-gcov-4.9 ທີ່ສາມາດດໍາເນີນການໄດ້ໃນ OnWorks ຜູ້ໃຫ້ບໍລິການໂຮດຕິ້ງຟຣີໂດຍໃຊ້ຫນຶ່ງໃນຫຼາຍບ່ອນເຮັດວຽກອອນໄລນ໌ຂອງພວກເຮົາເຊັ່ນ Ubuntu Online, Fedora Online, Windows online emulator ຫຼື MAC OS online emulator
ໂຄງການ:
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 ໄຟລ໌ຜົນຜະລິດ.
ໃຊ້ aarch64-linux-gnu-gcov-4.9 ອອນໄລນ໌ໂດຍໃຊ້ການບໍລິການ onworks.net