powerpc64-linux-gnu-gcov - ക്ലൗഡിൽ ഓൺലൈനിൽ

പട്ടിക:

NAME

gcov - കവറേജ് ടെസ്റ്റിംഗ് ടൂൾ

സിനോപ്സിസ്

gcov [-v|--പതിപ്പ്] [-h|--സഹായിക്കൂ]
[-a|--എല്ലാ ബ്ലോക്കുകളും]
[-b|--ശാഖ-സാധ്യതകൾ]
[-c|--ശാഖ-എണ്ണം]
[-d|--പ്രദർശനം-പുരോഗതി]
[-f|--ഫംഗ്ഷൻ-സംഗ്രഹങ്ങൾ]
[-i|--ഇന്റർമീഡിയറ്റ് ഫോർമാറ്റ്]
[-l|--long-file-names]
[-m|--വികലമായ-പേരുകൾ]
[-n|--നോ-ഔട്ട്പുട്ട്]
[-o|--object-ഡയറക്‌ടറി ഡയറക്ടറി|ഫയൽ]
[-p|--പാതകൾ സംരക്ഷിക്കുക]
[-r|--ബന്ധു-മാത്രം]
[-s|--ഉറവിടം-പ്രിഫിക്സ് ഡയറക്ടറി]
[-u|--നിരുപാധിക-ശാഖകൾ]
ഫയലുകൾ

വിവരണം

gcov ഒരു ടെസ്റ്റ് കവറേജ് പ്രോഗ്രാമാണ്. നിങ്ങളുടെ പ്രോഗ്രാമുകൾ വിശകലനം ചെയ്യാൻ ജിസിസിയുമായി ചേർന്ന് ഇത് ഉപയോഗിക്കുക
കൂടുതൽ കാര്യക്ഷമവും വേഗത്തിൽ പ്രവർത്തിക്കുന്നതുമായ കോഡ് സൃഷ്ടിക്കാനും നിങ്ങളുടെ പരിശോധിക്കാത്ത ഭാഗങ്ങൾ കണ്ടെത്താനും സഹായിക്കുക
പ്രോഗ്രാം. നിങ്ങൾക്ക് ഉപയോഗിക്കാം gcov നിങ്ങളുടെ ഒപ്റ്റിമൈസേഷൻ എവിടെയാണെന്ന് കണ്ടെത്താൻ സഹായിക്കുന്ന ഒരു പ്രൊഫൈലിംഗ് ഉപകരണമായി
ശ്രമങ്ങൾ നിങ്ങളുടെ കോഡിനെ ഏറ്റവും നന്നായി ബാധിക്കും. നിങ്ങൾക്ക് ഉപയോഗിക്കാനും കഴിയും gcov മറ്റ് പ്രൊഫൈലിംഗ് സഹിതം
ഉപകരണം, gprof, നിങ്ങളുടെ കോഡിന്റെ ഏതൊക്കെ ഭാഗങ്ങളാണ് ഏറ്റവും കൂടുതൽ കമ്പ്യൂട്ടിംഗ് സമയം ഉപയോഗിക്കുന്നത് എന്ന് വിലയിരുത്താൻ.

നിങ്ങളുടെ കോഡിന്റെ പ്രകടനം വിശകലനം ചെയ്യാൻ പ്രൊഫൈലിംഗ് ടൂളുകൾ നിങ്ങളെ സഹായിക്കുന്നു. പോലുള്ള ഒരു പ്രൊഫൈലർ ഉപയോഗിക്കുന്നു gcov
or gprof, ഇനിപ്പറയുന്നതുപോലുള്ള ചില അടിസ്ഥാന പ്രകടന സ്ഥിതിവിവരക്കണക്കുകൾ നിങ്ങൾക്ക് കണ്ടെത്താനാകും:

* കോഡിന്റെ ഓരോ വരിയും എത്ര തവണ എക്സിക്യൂട്ട് ചെയ്യുന്നു

* കോഡിന്റെ ഏത് ലൈനുകളാണ് യഥാർത്ഥത്തിൽ എക്സിക്യൂട്ട് ചെയ്യുന്നത്

* കോഡിന്റെ ഓരോ വിഭാഗവും എത്ര കമ്പ്യൂട്ടിംഗ് സമയം ഉപയോഗിക്കുന്നു

കംപൈൽ ചെയ്യുമ്പോൾ നിങ്ങളുടെ കോഡ് എങ്ങനെ പ്രവർത്തിക്കുന്നു എന്നതിനെക്കുറിച്ചുള്ള ഈ കാര്യങ്ങൾ നിങ്ങൾ അറിഞ്ഞുകഴിഞ്ഞാൽ, നിങ്ങൾക്ക് ഓരോന്നും നോക്കാം
ഏതൊക്കെ മൊഡ്യൂളുകളാണ് ഒപ്റ്റിമൈസ് ചെയ്യേണ്ടതെന്ന് കാണാൻ മൊഡ്യൂൾ. gcov എവിടെ ജോലി ചെയ്യണമെന്ന് നിർണ്ണയിക്കാൻ നിങ്ങളെ സഹായിക്കുന്നു
ഒപ്റ്റിമൈസേഷനിൽ.

സോഫ്‌റ്റ്‌വെയർ ഡെവലപ്പർമാർ ടെസ്റ്റ് സ്യൂട്ടുകൾക്കൊപ്പം കവറേജ് ടെസ്റ്റിംഗും ഉപയോഗിക്കുന്നു, ഉറപ്പാക്കാൻ
സോഫ്‌റ്റ്‌വെയർ യഥാർത്ഥത്തിൽ ഒരു റിലീസിന് മതിയായതാണ്. ടെസ്റ്റ് സ്യൂട്ടുകൾക്ക് ഒരു പ്രോഗ്രാം പരിശോധിക്കാൻ കഴിയും
പ്രതീക്ഷിച്ചതുപോലെ പ്രവർത്തിക്കുന്നു; ഒരു കവറേജ് പ്രോഗ്രാം പ്രോഗ്രാം എത്രത്തോളം ഉപയോഗിച്ചുവെന്ന് പരിശോധിക്കുന്നു
ടെസ്റ്റ്സ്യൂട്ട്. ഏത് തരത്തിലുള്ള ടെസ്റ്റ് കേസുകളിലേക്കാണ് ചേർക്കേണ്ടതെന്ന് ഡെവലപ്പർമാർക്ക് പിന്നീട് നിർണ്ണയിക്കാനാകും
മികച്ച ടെസ്റ്റിംഗും മികച്ച അന്തിമ ഉൽപ്പന്നവും സൃഷ്ടിക്കുന്നതിനുള്ള ടെസ്റ്റ് സ്യൂട്ടുകൾ.

നിങ്ങൾ ഉപയോഗിക്കാൻ ആഗ്രഹിക്കുന്നുവെങ്കിൽ ഒപ്റ്റിമൈസേഷൻ കൂടാതെ നിങ്ങളുടെ കോഡ് കംപൈൽ ചെയ്യണം gcov എന്തുകൊണ്ടെന്നാല്
ഒപ്റ്റിമൈസേഷൻ, ചില കോഡ് ലൈനുകൾ ഒരു ഫംഗ്‌ഷനിലേക്ക് സംയോജിപ്പിക്കുന്നതിലൂടെ, നിങ്ങൾക്ക് അത്രയും നൽകില്ല
കോഡ് വലിയ തോതിൽ ഉപയോഗിക്കുന്ന 'ഹോട്ട് സ്പോട്ടുകൾ' നിങ്ങൾ തിരയേണ്ടതിനാൽ വിവരങ്ങൾ
കമ്പ്യൂട്ടർ സമയം. അതുപോലെ, കാരണം gcov വരി പ്രകാരം സ്ഥിതിവിവരക്കണക്കുകൾ ശേഖരിക്കുന്നു (ഏറ്റവും താഴ്ന്നത്
റെസലൂഷൻ), ഓരോന്നിനും ഒരു പ്രസ്താവന മാത്രം നൽകുന്ന പ്രോഗ്രാമിംഗ് ശൈലിയിൽ ഇത് മികച്ച രീതിയിൽ പ്രവർത്തിക്കുന്നു
ലൈൻ. ലൂപ്പുകളിലേക്കോ മറ്റ് നിയന്ത്രണ ഘടനകളിലേക്കോ വികസിപ്പിക്കുന്ന സങ്കീർണ്ണമായ മാക്രോകൾ നിങ്ങൾ ഉപയോഗിക്കുകയാണെങ്കിൽ,
സ്ഥിതിവിവരക്കണക്കുകൾ സഹായകരമല്ല --- മാക്രോ കോൾ വരുന്ന ലൈനിൽ മാത്രമേ അവ റിപ്പോർട്ട് ചെയ്യുകയുള്ളൂ
പ്രത്യക്ഷപ്പെടുന്നു. നിങ്ങളുടെ സങ്കീർണ്ണമായ മാക്രോകൾ ഫംഗ്‌ഷനുകൾ പോലെയാണ് പ്രവർത്തിക്കുന്നതെങ്കിൽ, നിങ്ങൾക്ക് അവയെ ഇൻലൈൻ ഉപയോഗിച്ച് മാറ്റിസ്ഥാപിക്കാം
ഈ പ്രശ്നം പരിഹരിക്കുന്നതിനുള്ള പ്രവർത്തനങ്ങൾ.

gcov എന്ന ഒരു ലോഗ്ഫയൽ സൃഷ്ടിക്കുന്നു sourcefile.gcov ഓരോ വരിയുടെയും എത്ര തവണ സൂചിപ്പിക്കുന്നു
ഒരു സോഴ്സ് ഫയൽ sourcefile.c നടപ്പിലാക്കിയിട്ടുണ്ട്. ഇതോടൊപ്പം നിങ്ങൾക്ക് ഈ ലോഗ്ഫയലുകൾ ഉപയോഗിക്കാം gprof ലേക്ക്
നിങ്ങളുടെ പ്രോഗ്രാമുകളുടെ പ്രകടനം നന്നായി ക്രമീകരിക്കാൻ സഹായിക്കുന്നു. gprof നിങ്ങൾക്ക് സമയ വിവരങ്ങൾ നൽകുന്നു
നിങ്ങൾക്ക് ലഭിക്കുന്ന വിവരങ്ങൾക്കൊപ്പം ഉപയോഗിക്കാം gcov.

gcov ജിസിസിയിൽ കംപൈൽ ചെയ്ത കോഡിൽ മാത്രം പ്രവർത്തിക്കുന്നു. ഇത് മറ്റേതെങ്കിലും പ്രൊഫൈലിങ്ങുമായി പൊരുത്തപ്പെടുന്നില്ല
അല്ലെങ്കിൽ ടെസ്റ്റ് കവറേജ് മെക്കാനിസം.

ഓപ്ഷനുകൾ

-h
--സഹായിക്കൂ
ഉപയോഗിക്കുന്നതിനുള്ള സഹായം പ്രദർശിപ്പിക്കുക gcov (സ്റ്റാൻഡേർഡ് ഔട്ട്പുട്ടിൽ), ഒന്നും ചെയ്യാതെ പുറത്തുകടക്കുക
കൂടുതൽ പ്രോസസ്സിംഗ്.

-v
--പതിപ്പ്
പ്രദർശിപ്പിക്കുക gcov പതിപ്പ് നമ്പർ (സാധാരണ ഔട്ട്പുട്ടിൽ), ഒന്നും ചെയ്യാതെ പുറത്തുകടക്കുക
കൂടുതൽ പ്രോസസ്സിംഗ്.

-a
--എല്ലാ ബ്ലോക്കുകളും
ഓരോ അടിസ്ഥാന ബ്ലോക്കിനും വ്യക്തിഗത എക്സിക്യൂഷൻ എണ്ണം എഴുതുക. സാധാരണയായി gcov ഔട്ട്പുട്ടുകൾ
ഒരു വരിയുടെ പ്രധാന ബ്ലോക്കുകൾക്ക് മാത്രമേ എക്സിക്യൂഷൻ കണക്കാക്കൂ. ഈ ഓപ്ഷൻ ഉപയോഗിച്ച് നിങ്ങൾക്ക് കഴിയും
ഒരു വരിക്കുള്ളിലെ ബ്ലോക്കുകൾ എക്സിക്യൂട്ട് ചെയ്യുന്നില്ലേ എന്ന് നിർണ്ണയിക്കുക.

-b
--ശാഖ-സാധ്യതകൾ
ഔട്ട്‌പുട്ട് ഫയലിലേക്ക് ബ്രാഞ്ച് ഫ്രീക്വൻസികൾ എഴുതുക, ബ്രാഞ്ച് സംഗ്രഹ വിവരം ഇതിലേക്ക് എഴുതുക
സ്റ്റാൻഡേർഡ് ഔട്ട്പുട്ട്. നിങ്ങളുടെ പ്രോഗ്രാമിലെ ഓരോ ബ്രാഞ്ചും എത്ര തവണ കാണുന്നതിന് ഈ ഓപ്ഷൻ നിങ്ങളെ അനുവദിക്കുന്നു
എടുക്കപ്പെട്ടു. അല്ലാതെ നിരുപാധികമായ ശാഖകൾ കാണിക്കില്ല -u ഓപ്ഷൻ നൽകിയിരിക്കുന്നു.

-c
--ശാഖ-എണ്ണം
ബ്രാഞ്ച് ഫ്രീക്വൻസികൾ ശതമാനത്തിന് പകരം എടുത്ത ശാഖകളുടെ എണ്ണമായി എഴുതുക
എടുത്ത ശാഖകളുടെ.

-n
--നോ-ഔട്ട്പുട്ട്
സൃഷ്ടിക്കരുത് gcov ഔട്ട്പുട്ട് ഫയൽ.

-l
--long-file-names
ഉൾപ്പെടുത്തിയ സോഴ്സ് ഫയലുകൾക്കായി നീണ്ട ഫയൽ നാമങ്ങൾ സൃഷ്ടിക്കുക. ഉദാഹരണത്തിന്, ഹെഡ്ഡർ ഫയൽ ആണെങ്കിൽ xh
കോഡ് അടങ്ങിയിരിക്കുന്നു, ഫയലിൽ ഉൾപ്പെടുത്തിയിട്ടുണ്ട് ac, പിന്നെ ഓടുന്നു gcov ഫയലിൽ ac
എന്ന ഒരു ഔട്ട്പുട്ട് ഫയൽ നിർമ്മിക്കും ac##xhgcov ഇതിനുപകരമായി xhgcov. ഇത് ആകാം
എങ്കിൽ ഉപയോഗപ്രദമാണ് xh ഒന്നിലധികം ഉറവിട ഫയലുകളിൽ ഉൾപ്പെടുത്തിയിട്ടുണ്ട്, നിങ്ങൾക്ക് വ്യക്തിയെ കാണാൻ താൽപ്പര്യമുണ്ട്
സംഭാവനകൾ. നിങ്ങൾ ഉപയോഗിക്കുകയാണെങ്കിൽ -p ഓപ്ഷൻ, ഉൾപ്പെടുന്നതും ഉൾപ്പെടുത്തിയതുമായ ഫയൽ നാമങ്ങൾ
പൂർണ്ണമായ പാത നാമങ്ങളായിരിക്കും.

-p
--പാതകൾ സംരക്ഷിക്കുക
സൃഷ്ടിച്ചവയുടെ പേരുകളിൽ പൂർണ്ണമായ പാത്ത് വിവരങ്ങൾ സൂക്ഷിക്കുക .gcov ഫയലുകൾ. കൂടാതെ
ഈ ഐച്ഛികം, ഫയൽനാമ ഘടകം മാത്രമാണ് ഉപയോഗിക്കുന്നത്. ഈ ഓപ്ഷൻ ഉപയോഗിച്ച്, എല്ലാ ഡയറക്ടറികളും
ഉപയോഗിക്കുന്നു, കൂടെ / പ്രതീകങ്ങൾ വിവർത്തനം ചെയ്തു # കഥാപാത്രങ്ങൾ, . ഡയറക്ടറി ഘടകങ്ങൾ നീക്കം ചെയ്തു
നീക്കം ചെയ്യാനാവാത്തതും .. ഘടകങ്ങൾ എന്ന് പുനർനാമകരണം ചെയ്തു ^. സോഴ്‌സ് ഫയലുകൾ ഉള്ളതാണെങ്കിൽ ഇത് ഉപയോഗപ്രദമാണ്
നിരവധി വ്യത്യസ്ത ഡയറക്ടറികൾ.

-r
--ബന്ധു-മാത്രം
ആപേക്ഷിക പാത്ത്‌നെയിം ഉള്ള സോഴ്‌സ് ഫയലുകളെക്കുറിച്ചുള്ള വിവരങ്ങൾ മാത്രം ഔട്ട്‌പുട്ട് ചെയ്യുക (ഉറവിടത്തിന് ശേഷം
പ്രിഫിക്സ് എലിഷൻ). സമ്പൂർണ്ണ പാതകൾ സാധാരണയായി സിസ്റ്റം ഹെഡർ ഫയലുകളും ഏതെങ്കിലും കവറേജുമാണ്
ഇൻലൈൻ ഫംഗ്‌ഷനുകൾ സാധാരണയായി താൽപ്പര്യമില്ലാത്തതാണ്.

-f
--ഫംഗ്ഷൻ-സംഗ്രഹങ്ങൾ
ഫയൽ ലെവൽ സംഗ്രഹത്തിന് പുറമെ ഓരോ ഫംഗ്‌ഷനുമുള്ള ഔട്ട്‌പുട്ട് സംഗ്രഹങ്ങൾ.

-o ഡയറക്ടറി|ഫയൽ
--object-ഡയറക്‌ടറി ഡയറക്ടറി
--object-file ഫയല്
ഒന്നുകിൽ gcov ഡാറ്റ ഫയലുകൾ അടങ്ങിയിരിക്കുന്ന ഡയറക്ടറി അല്ലെങ്കിൽ ഒബ്ജക്റ്റ് പാത്ത് പേര് വ്യക്തമാക്കുക.
ദി .gcno, ഒപ്പം .gcda ഈ ഓപ്ഷൻ ഉപയോഗിച്ച് ഡാറ്റ ഫയലുകൾ തിരയുന്നു. ഒരു ഡയറക്ടറി ആണെങ്കിൽ
വ്യക്തമാക്കിയത്, ഡാറ്റ ഫയലുകൾ ആ ഡയറക്‌ടറിയിലാണെന്നും ഇൻപുട്ട് ഫയലിന്റെ പേരിന്റെ പേരിലാണ്,
അതിന്റെ വിപുലീകരണം കൂടാതെ. ഒരു ഫയൽ ഇവിടെ വ്യക്തമാക്കിയിട്ടുണ്ടെങ്കിൽ, ഡാറ്റ ഫയലുകൾക്ക് പേരിടും
ആ ഫയൽ, അതിന്റെ വിപുലീകരണമില്ലാതെ.

-s ഡയറക്ടറി
--ഉറവിടം-പ്രിഫിക്സ് ഡയറക്ടറി
ഔട്ട്‌പുട്ട് കവറേജ് ഫയലുകൾ സൃഷ്‌ടിക്കുമ്പോൾ നീക്കം ചെയ്യേണ്ട ഉറവിട ഫയലുകളുടെ പേരുകൾക്കുള്ള ഒരു പ്രിഫിക്‌സ്.
ഒരു പ്രത്യേക ഡയറക്ടറിയിൽ നിർമ്മിക്കുമ്പോൾ ഈ ഐച്ഛികം ഉപയോഗപ്രദമാണ്, കൂടാതെ ഇതിലേക്കുള്ള പാത്ത് നെയിം
ഔട്ട്പുട്ട് ഫയലുകളുടെ പേരുകൾ നിർണ്ണയിക്കുമ്പോൾ സോഴ്സ് ഡയറക്ടറി ആവശ്യമില്ല. ഇത് ശ്രദ്ധിക്കുക
ഉറവിട ഫയൽ കേവലമാണോ എന്ന് നിർണ്ണയിക്കുന്നതിന് മുമ്പ് പ്രിഫിക്സ് ഡിറ്റക്ഷൻ പ്രയോഗിക്കുന്നു.

-u
--നിരുപാധിക-ശാഖകൾ
ബ്രാഞ്ച് സാധ്യതകൾ നൽകുമ്പോൾ, ഉപാധികളില്ലാത്ത ശാഖകളുടേത് ഉൾപ്പെടുത്തുക.
ഉപാധികളില്ലാത്ത ശാഖകൾ സാധാരണയായി രസകരമല്ല.

-d
--പ്രദർശനം-പുരോഗതി
സ്റ്റാൻഡേർഡ് ഔട്ട്പുട്ടിൽ പുരോഗതി പ്രദർശിപ്പിക്കുക.

-i
--ഇന്റർമീഡിയറ്റ് ഫോർമാറ്റ്
എളുപ്പത്തിൽ പാഴ്‌സ് ചെയ്യാവുന്ന ഇന്റർമീഡിയറ്റ് ടെക്‌സ്‌റ്റ് ഫോർമാറ്റിൽ gcov ഫയൽ ഔട്ട്‌പുട്ട് ചെയ്യുക lcov
അല്ലെങ്കിൽ മറ്റ് ഉപകരണങ്ങൾ. ഔട്ട്പുട്ട് ഒരു സിംഗിൾ ആണ് .gcov ഓരോ ഫയൽ .gcda ഫയൽ. സോഴ്സ് കോഡ് ഒന്നുമില്ല
ആവശ്യമാണ്.

ഇന്റർമീഡിയറ്റിന്റെ ഫോർമാറ്റ് .gcov ഫയൽ ഒരു വരിയിൽ ഒരു എൻട്രി ഉള്ള പ്ലെയിൻ ടെക്സ്റ്റാണ്

ഫയൽ:
പ്രവർത്തനം: , ,
എണ്ണം: ,
ശാഖ: ,

എവിടെ ആണ്
notexec (ശാഖ നടപ്പിലാക്കിയിട്ടില്ല)
എടുത്തത് (ശാഖ നിർവ്വഹിച്ചതും എടുത്തതും)
എടുത്തിട്ടില്ല (ശാഖ നിർവഹിച്ചു, പക്ഷേ എടുത്തിട്ടില്ല)

ഒന്നിലധികം ഉണ്ടാകാം ഒരു ഇന്റർമീഡിയറ്റ് gcov-ലെ എൻട്രികൾ
ഫയൽ. ഇനിപ്പറയുന്ന എല്ലാ എൻട്രികളും a ആ സോഴ്സ് ഫയലുമായി ബന്ധപ്പെട്ടതാണ്
അടുത്തത് വരെ പ്രവേശനം.

എപ്പോൾ ഇതാ ഒരു സാമ്പിൾ -i എന്നിവയുമായി ചേർന്ന് ഉപയോഗിക്കുന്നു -b ഓപ്ഷൻ:

ഫയൽ:array.cc
ഫംഗ്‌ഷൻ:11,1,_Z3sumRKSt6vectorIPiSaIS0_EE
ഫംഗ്ഷൻ: 22,1, പ്രധാന
എണ്ണം:11,1
എണ്ണം:12,1
എണ്ണം:14,1
ബ്രാഞ്ച്:14,എടുത്തു
എണ്ണം:26,1
ശാഖ: 28, എടുത്തിട്ടില്ല

-m
--വികലമായ-പേരുകൾ
ഔട്ട്‌പുട്ടിൽ ഡീമാംഗിൾ ചെയ്ത ഫംഗ്‌ഷൻ പേരുകൾ പ്രദർശിപ്പിക്കുക. മംഗൾഡ് ഫംഗ്‌ഷൻ കാണിക്കുക എന്നതാണ് ഡിഫോൾട്ട്
പേരുകൾ.

gcov നിങ്ങൾ അഭ്യർത്ഥിച്ച അതേ ഡയറക്‌ടറിയിൽ പ്രവർത്തിക്കണം
കമ്പൈലർ. അല്ലെങ്കിൽ അതിന് സോഴ്‌സ് ഫയലുകൾ കണ്ടെത്താൻ കഴിയില്ല. gcov ഫയലുകൾ നിർമ്മിക്കുന്നു
വിളിച്ചു mangledname.gcov നിലവിലെ ഡയറക്ടറിയിൽ. ഇവയിൽ കവറേജ് വിവരങ്ങൾ അടങ്ങിയിരിക്കുന്നു
അവയുമായി ബന്ധപ്പെട്ട ഉറവിട ഫയലിന്റെ. ഒന്ന് .gcov ഓരോ ഉറവിടത്തിനും വേണ്ടി ഫയൽ നിർമ്മിക്കുന്നു (അല്ലെങ്കിൽ
ഹെഡ്ഡർ) ഡാറ്റ ഫയലുകൾ നിർമ്മിക്കുന്നതിനായി കംപൈൽ ചെയ്ത കോഡ് അടങ്ങിയ ഫയൽ. ദി
മംഗളനാമം ഔട്ട്‌പുട്ട് ഫയലിന്റെ ഒരു ഭാഗം സാധാരണയായി സോഴ്‌സ് ഫയലിന്റെ പേരായിരിക്കും, പക്ഷേ കഴിയും
എങ്കിൽ കൂടുതൽ സങ്കീർണ്ണമായ എന്തെങ്കിലും ആയിരിക്കും -l or -p ഓപ്ഷനുകൾ നൽകിയിരിക്കുന്നു. ആ ഓപ്ഷനുകൾ നോക്കുക
വിവരങ്ങൾക്ക്.

നിങ്ങൾ വിളിച്ചാൽ gcov ഒന്നിലധികം ഇൻപുട്ട് ഫയലുകൾക്കൊപ്പം, ഓരോ ഇൻപുട്ട് ഫയലിൽ നിന്നുമുള്ള സംഭാവനകൾ
സംഗ്രഹിച്ചു. സാധാരണഗതിയിൽ, അവസാന ലിങ്ക് പോലെ ഫയലുകളുടെ അതേ ലിസ്റ്റ് ഉപയോഗിച്ച് നിങ്ങൾ ഇത് അഭ്യർത്ഥിക്കും
നിങ്ങളുടെ എക്സിക്യൂട്ടബിൾ.

ദി .gcov ഫയലുകളിൽ അടങ്ങിയിരിക്കുന്നു : പ്രോഗ്രാം സോഴ്സ് കോഡിനൊപ്പം വേർതിരിച്ച ഫീൽഡുകൾ. ഫോർമാറ്റ്
is

: :

കമാൻഡ് ലൈൻ ഓപ്ഷൻ അഭ്യർത്ഥിക്കുമ്പോൾ, ഓരോ വരിയിലും അധിക ബ്ലോക്ക് വിവരങ്ങൾ വിജയിച്ചേക്കാം.
ദി എക്സിക്യൂഷൻ_കൗണ്ട് is - കോഡ് ഇല്ലാത്ത വരികൾക്ക്. നടപ്പിലാക്കാത്ത വരികൾ അടയാളപ്പെടുത്തിയിരിക്കുന്നു #####
or ====, അസാധാരണമല്ലാത്ത പാതകളിലൂടെ അവ എത്തിച്ചേരാനാകുമോ എന്നതിനെ ആശ്രയിച്ചിരിക്കുന്നു
യഥാക്രമം C++ എക്സപ്ഷൻ ഹാൻഡ്‌ലറുകൾ പോലെയുള്ള അസാധാരണ പാതകൾ.

തുടക്കത്തിൽ ചില വിവരങ്ങൾ ഉണ്ട് ലൈൻ_നമ്പർ പൂജ്യത്തിന്റെ. ഈ ആമുഖ വരികൾ
രൂപത്തിന്റെ

-:0: :

ഈ ആമുഖ വരികളുടെ ക്രമവും എണ്ണവും ഇങ്ങനെ വർദ്ധിപ്പിക്കും gcov വികസനം
പുരോഗമിക്കുന്നു --- മാറ്റമില്ലാതെ തുടരുന്ന അവയിൽ ആശ്രയിക്കരുത്. ഉപയോഗിക്കുക ടാഗ് ഒരു പ്രത്യേക സ്ഥാനം കണ്ടെത്താൻ
ആമുഖ വരി.

അധിക ബ്ലോക്ക് വിവരങ്ങൾ ഫോമിന്റെതാണ്



ദി വിവരം മനുഷ്യർക്ക് വായിക്കാൻ കഴിയും, എന്നാൽ മെഷീൻ പാഴ്‌സിംഗ് ചെയ്യാൻ കഴിയുന്നത്ര ലളിതമായി രൂപകൽപ്പന ചെയ്‌തിരിക്കുന്നു
വളരെ.

ശതമാനം അച്ചടിക്കുമ്പോൾ, മൂല്യങ്ങൾ ഉള്ളപ്പോൾ മാത്രമേ 0%, 100% എന്നിവ അച്ചടിക്കുകയുള്ളൂ കൃത്യമായി 0% ഉം
യഥാക്രമം 100%. പരമ്പരാഗതമായി 0% അല്ലെങ്കിൽ 100% ആയി റൗണ്ട് ചെയ്യപ്പെടുന്ന മറ്റ് മൂല്യങ്ങൾ
പകരം ഏറ്റവും അടുത്തുള്ള നോൺ-ബൗണ്ടറി മൂല്യമായി അച്ചടിച്ചു.

ഉപയോഗിക്കുമ്പോൾ gcov, നിങ്ങൾ ആദ്യം രണ്ട് പ്രത്യേക GCC ഓപ്ഷനുകൾ ഉപയോഗിച്ച് നിങ്ങളുടെ പ്രോഗ്രാം കംപൈൽ ചെയ്യണം:
-fprofile-arcs -ftest-കവറേജ്. ഇത് കംപൈലറോട് അധികമായി സൃഷ്ടിക്കാൻ പറയുന്നു
gcov-ന് ആവശ്യമായ വിവരങ്ങൾ (അടിസ്ഥാനപരമായി പ്രോഗ്രാമിന്റെ ഒരു ഫ്ലോ ഗ്രാഫ്) കൂടാതെ ഉൾപ്പെടുന്നു
ആവശ്യമായ അധിക പ്രൊഫൈലിംഗ് വിവരങ്ങൾ സൃഷ്ടിക്കുന്നതിന് ഒബ്ജക്റ്റ് ഫയലുകളിൽ അധിക കോഡ്
gcov മുഖേന ഈ അധിക ഫയലുകൾ ഒബ്ജക്റ്റ് ഫയൽ ഉള്ള ഡയറക്ടറിയിൽ സ്ഥാപിച്ചിരിക്കുന്നു
സ്ഥിതി ചെയ്യുന്നത്.

പ്രോഗ്രാം പ്രവർത്തിപ്പിക്കുന്നത് പ്രൊഫൈൽ ഔട്ട്പുട്ട് ജനറേറ്റുചെയ്യുന്നതിന് കാരണമാകും. ഓരോ സോഴ്സ് ഫയലിനും
ഉപയോഗിച്ച് സമാഹരിച്ചത് -fprofile-arcs, ഒരു അനുഗമിക്കുന്ന .gcda ഫയൽ ഒബ്ജക്റ്റ് ഫയലിൽ സ്ഥാപിക്കും
ഡയറക്ടറി.

പ്രവർത്തിക്കുന്ന gcov നിങ്ങളുടെ പ്രോഗ്രാമിന്റെ സോഴ്സ് ഫയൽ പേരുകൾ ഉപയോഗിച്ച് ആർഗ്യുമെന്റുകൾ ഇപ്പോൾ ഒരു ലിസ്റ്റിംഗ് ഉണ്ടാക്കും
ഓരോ വരിയുടെയും എക്സിക്യൂഷൻ ഫ്രീക്വൻസി സഹിതം കോഡിന്റെ. ഉദാഹരണത്തിന്, നിങ്ങളുടെ പ്രോഗ്രാം ആണെങ്കിൽ
വിളിച്ചു tmp.c, നിങ്ങൾ അടിസ്ഥാനം ഉപയോഗിക്കുമ്പോൾ നിങ്ങൾ കാണുന്നത് ഇതാണ് gcov സൗകര്യം:

$ gcc -fprofile-arcs -ftest-coverage tmp.c
$ a.out
$ gcov tmp.c
tmp.c ഫയലിൽ എക്സിക്യൂട്ട് ചെയ്ത 90.00 ഉറവിട ലൈനുകളിൽ 10%
tmp.c.gcov സൃഷ്ടിക്കുന്നു.

ഫയൽ tmp.c.gcov എന്നതിൽ നിന്നുള്ള ഔട്ട്പുട്ട് അടങ്ങിയിരിക്കുന്നു gcov. ഇതാ ഒരു സാമ്പിൾ:

-: 0:ഉറവിടം:tmp.c
-: 0:ഗ്രാഫ്:tmp.gcno
-: 0:Data:tmp.gcda
-: 0:റൺസ്:1
-: 0:പ്രോഗ്രാമുകൾ:1
-: 1:#ഉൾപ്പെടുത്തുക
-: 2:
-: 3:ഇന്റ് മെയിൻ (അസാധു)
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 ഓപ്ഷൻ, നിങ്ങൾക്ക് വ്യക്തിഗത ബ്ലോക്ക് കൗണ്ടുകളും ഔട്ട്പുട്ട് ലുക്കും ലഭിക്കും
ഇതുപോലെ:

-: 0:ഉറവിടം:tmp.c
-: 0:ഗ്രാഫ്:tmp.gcno
-: 0:Data:tmp.gcda
-: 0:റൺസ്:1
-: 0:പ്രോഗ്രാമുകൾ:1
-: 1:#ഉൾപ്പെടുത്തുക
-: 2:
-: 3:ഇന്റ് മെയിൻ (അസാധു)
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-ബ്ലോക്ക് 0
-: 14: വേറെ
1: 15: printf ("വിജയം\n");
1: 15-ബ്ലോക്ക് 0
1: 16: റിട്ടേൺ 0;
1: 16-ബ്ലോക്ക് 0
-: 17:}

ഈ മോഡിൽ, ഓരോ അടിസ്ഥാന ബ്ലോക്കും ഒരു വരിയിൽ മാത്രമേ കാണിക്കൂ -- ബ്ലോക്കിന്റെ അവസാന വരി. എ
മൾട്ടി-ലൈൻ ബ്ലോക്ക് ആ അവസാന വരിയുടെ എക്സിക്യൂഷൻ എണ്ണത്തിന് മാത്രമേ സംഭാവന നൽകൂ
മുൻ ബ്ലോക്കുകൾ ആ വരികളിൽ അവസാനിക്കുന്നില്ലെങ്കിൽ, വരികളിൽ കോഡ് അടങ്ങിയിരിക്കുന്നതായി കാണിക്കില്ല. ദി
ഒരു വരിയുടെ മൊത്തം എക്സിക്യൂഷൻ എണ്ണം കാണിക്കുന്നു, തുടർന്നുള്ള വരികൾ എക്സിക്യൂഷൻ കൗണ്ടുകൾ കാണിക്കുന്നു
ആ വരിയിൽ അവസാനിക്കുന്ന വ്യക്തിഗത ബ്ലോക്കുകൾക്കായി. ഓരോ ബ്ലോക്കിനും ശേഷം, ബ്രാഞ്ചും കോളും കണക്കാക്കുന്നു
എങ്കിൽ ബ്ലോക്കിന്റെ ഭാഗം കാണിക്കും -b ഓപ്ഷൻ നൽകിയിരിക്കുന്നു.

GCC ഉപകരണങ്ങൾ വിളിക്കുന്ന രീതി കാരണം, നമ്പർ ഉള്ള ഒരു വരിക്ക് ശേഷം ഒരു കോൾ എണ്ണം കാണിക്കാനാകും
വ്യക്തിഗത ബ്ലോക്കുകൾ. നിങ്ങൾക്ക് കാണാനാകുന്നതുപോലെ, ലൈൻ 13-ൽ എക്സിക്യൂട്ട് ചെയ്യാത്ത ഒരു അടിസ്ഥാന ബ്ലോക്ക് അടങ്ങിയിരിക്കുന്നു.

നിങ്ങൾ ഉപയോഗിക്കുമ്പോൾ -b ഓപ്ഷൻ, നിങ്ങളുടെ ഔട്ട്പുട്ട് ഇതുപോലെ കാണപ്പെടുന്നു:

$ gcov -b tmp.c
tmp.c ഫയലിൽ എക്സിക്യൂട്ട് ചെയ്ത 90.00 ഉറവിട ലൈനുകളിൽ 10%
80.00 ശാഖകളിൽ 5% ഫയലിൽ tmp.c
tmp.c ഫയലിൽ ഒരിക്കലെങ്കിലും എടുത്ത 80.00 ശാഖകളിൽ 5%
50.00 കോളുകളുടെ 2% tmp.c ഫയലിൽ എക്‌സിക്യൂട്ട് ചെയ്‌തു
tmp.c.gcov സൃഷ്ടിക്കുന്നു.

ഫലത്തിന്റെ ഒരു സാമ്പിൾ ഇതാ tmp.c.gcov ഫയൽ:

-: 0:ഉറവിടം:tmp.c
-: 0:ഗ്രാഫ്:tmp.gcno
-: 0:Data:tmp.gcda
-: 0:റൺസ്:1
-: 0:പ്രോഗ്രാമുകൾ:1
-: 1:#ഉൾപ്പെടുത്തുക
-: 2:
-: 3:ഇന്റ് മെയിൻ (അസാധു)
ഫംഗ്‌ഷൻ മെയിൻ 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, പ്രൊഫൈലിംഗ് കോഡ് ആദ്യം ഒരു വായിക്കാൻ ശ്രമിക്കുന്നു
നിലവിലുള്ളത് .gcda ഫയൽ; ഫയൽ എക്സിക്യൂട്ടബിളുമായി പൊരുത്തപ്പെടുന്നില്ലെങ്കിൽ (അടിസ്ഥാനത്തിന്റെ വ്യത്യസ്ത എണ്ണം
ബ്ലോക്ക് എണ്ണം) അത് ഫയലിന്റെ ഉള്ളടക്കം അവഗണിക്കും. അത് പിന്നീട് പുതിയ എക്സിക്യൂഷനിൽ ചേർക്കുന്നു
ഫയലിലേക്ക് ഡാറ്റ എണ്ണുകയും അവസാനം എഴുതുകയും ചെയ്യുന്നു.

ഉപയോഗിക്കുന്നു gcov കൂടെ ജിസിസി ഒപ്റ്റിമൈസേഷൻ

നിങ്ങൾ ഉപയോഗിക്കാൻ ആഗ്രഹിക്കുന്നുവെങ്കിൽ gcov നിങ്ങളുടെ കോഡ് ഒപ്റ്റിമൈസ് ചെയ്യാൻ സഹായിക്കുന്നതിന്, നിങ്ങൾ ആദ്യം നിങ്ങളുടെ പ്രോഗ്രാം കംപൈൽ ചെയ്യണം
രണ്ട് പ്രത്യേക GCC ഓപ്ഷനുകൾക്കൊപ്പം: -fprofile-arcs -ftest-കവറേജ്. അത് മാറ്റിനിർത്തിയാൽ, നിങ്ങൾക്ക് കഴിയും
മറ്റേതെങ്കിലും GCC ഓപ്ഷനുകൾ ഉപയോഗിക്കുക; എന്നാൽ നിങ്ങളുടെ പ്രോഗ്രാമിലെ ഓരോ വരിയും തെളിയിക്കാൻ നിങ്ങൾ ആഗ്രഹിക്കുന്നുവെങ്കിൽ
എക്സിക്യൂട്ട് ചെയ്തു, നിങ്ങൾ ഒരേ സമയം ഒപ്റ്റിമൈസേഷൻ ഉപയോഗിച്ച് കംപൈൽ ചെയ്യരുത്. ചില മെഷീനുകളിൽ
ഒപ്റ്റിമൈസർ ചില ലളിതമായ കോഡ് ലൈനുകൾ മറ്റ് ലൈനുകളുമായി സംയോജിപ്പിച്ച് ഇല്ലാതാക്കാൻ കഴിയും.
ഉദാഹരണത്തിന്, ഇതുപോലുള്ള കോഡ്:

എങ്കിൽ (a!= b)
c = 1;
മറ്റാരെങ്കിലും
c = 0;

ചില മെഷീനുകളിൽ ഒരു നിർദ്ദേശമായി സമാഹരിക്കാം. ഈ സാഹചര്യത്തിൽ, ഒരു മാർഗവുമില്ല
gcov വെവ്വേറെ ഇല്ലാത്തതിനാൽ ഓരോ വരിയ്ക്കും വെവ്വേറെ എക്സിക്യൂഷൻ എണ്ണം കണക്കാക്കാൻ
ഓരോ വരിയുടെയും കോഡ്. അതിനാൽ gcov നിങ്ങൾ പ്രോഗ്രാം കംപൈൽ ചെയ്താൽ ഔട്ട്പുട്ട് ഇതുപോലെ കാണപ്പെടുന്നു
ഒപ്റ്റിമൈസേഷൻ ഉപയോഗിച്ച്:

100: 12:എങ്കിൽ (a != b)
100: 13: c = 1;
100: 14: വേറെ
100: 15: c = 0;

ഒപ്റ്റിമൈസേഷൻ സംയോജിപ്പിച്ച് കോഡിന്റെ ഈ ബ്ലോക്ക് 100 തവണ എക്സിക്യൂട്ട് ചെയ്തതായി ഔട്ട്പുട്ട് കാണിക്കുന്നു.
ഒരർത്ഥത്തിൽ ഈ ഫലം ശരിയാണ്, കാരണം ഒരു നിർദ്ദേശം മാത്രമേ പ്രതിനിധീകരിക്കുന്നുള്ളൂ
ഈ നാല് വരികളും. എന്നിരുന്നാലും, ഫലം എത്ര തവണയാണെന്ന് ഔട്ട്പുട്ട് സൂചിപ്പിക്കുന്നില്ല
0 ആയിരുന്നു, എത്ര തവണ ഫലം 1 ആയിരുന്നു.

ഇൻലൈനബിൾ ഫംഗ്‌ഷനുകൾക്ക് അപ്രതീക്ഷിത വരികളുടെ എണ്ണം സൃഷ്‌ടിക്കാൻ കഴിയും. ഇതിനായി വരികളുടെ എണ്ണം കാണിച്ചിരിക്കുന്നു
ഇൻലൈനബിൾ ഫംഗ്‌ഷന്റെ സോഴ്‌സ് കോഡ്, എന്നാൽ കാണിക്കുന്നത് ഫംഗ്‌ഷൻ എവിടെയാണെന്നതിനെ ആശ്രയിച്ചിരിക്കുന്നു
ഇൻലൈൻ, അല്ലെങ്കിൽ അത് ഇൻലൈൻ ചെയ്തിട്ടില്ലെങ്കിൽ.

ഫംഗ്‌ഷൻ ഇൻലൈൻ ചെയ്‌തിട്ടില്ലെങ്കിൽ, കംപൈലർ അതിന്റെ ഒരു ഔട്ട്‌ലൈൻ കോപ്പി പുറപ്പെടുവിക്കണം
ഫംഗ്‌ഷൻ, ആവശ്യമുള്ള ഏതൊരു ഒബ്‌ജക്റ്റ് ഫയലിലും. എങ്കിൽ ഫയൽഎ.ഒ ഒപ്പം ഫയൽ ബി.ഒ രണ്ടും പുറത്ത് അടങ്ങിയിരിക്കുന്നു
ഒരു പ്രത്യേക ഇൻലൈനബിൾ ഫംഗ്‌ഷന്റെ ലൈൻ ബോഡികൾ, അവ രണ്ടിലും കവറേജ് അടങ്ങിയിരിക്കും
ആ ഫംഗ്‌ഷനായി കണക്കാക്കുന്നു. എപ്പോൾ ഫയൽഎ.ഒ ഒപ്പം ഫയൽ ബി.ഒ പരസ്പരം ബന്ധിപ്പിച്ചിരിക്കുന്നു, ലിങ്കർ ചെയ്യും,
പല സിസ്റ്റങ്ങളിലും, ആ ഫംഗ്‌ഷനിലേക്കുള്ള എല്ലാ കോളുകൾക്കുമായി ലൈനിന് പുറത്തുള്ളവയിൽ ഒന്ന് തിരഞ്ഞെടുക്കുക,
മറ്റൊന്ന് നീക്കം ചെയ്യുക അല്ലെങ്കിൽ അവഗണിക്കുക. നിർഭാഗ്യവശാൽ, ഇത് കവറേജ് കൗണ്ടറുകൾ നീക്കം ചെയ്യില്ല
ഉപയോഗിക്കാത്ത ഫംഗ്ഷൻ ബോഡിക്ക്. അതിനാൽ ഇൻസ്ട്രുമെന്റ് ചെയ്യുമ്പോൾ, ആ ഫംഗ്ഷന്റെ ഒരു ഉപയോഗം ഒഴികെ
പൂജ്യം എണ്ണം കാണിക്കും.

ഫംഗ്‌ഷൻ നിരവധി സ്ഥലങ്ങളിൽ ഇൻലൈൻ ചെയ്‌തിട്ടുണ്ടെങ്കിൽ, ഓരോ ലൊക്കേഷനിലെയും ബ്ലോക്ക് ഘടന ഉണ്ടാകാം
അതുപോലെ ആയിരിക്കരുത്. ഉദാഹരണത്തിന്, കംപൈൽ സമയത്ത് ഒരു വ്യവസ്ഥ ഇപ്പോൾ കണക്കാക്കാം
ചില സന്ദർഭങ്ങൾ. കാരണം ഇൻലൈൻ ഫംഗ്‌ഷന്റെ എല്ലാ ഉപയോഗങ്ങളുടെയും കവറേജ് കാണിക്കും
അതേ സോഴ്സ് ലൈനുകൾക്ക്, ലൈൻ കൗണ്ടുകൾ തന്നെ പൊരുത്തമില്ലാത്തതായി തോന്നിയേക്കാം.

ദീർഘകാലമായി പ്രവർത്തിക്കുന്ന ആപ്ലിക്കേഷനുകൾക്ക് "_gcov_reset", "_gcov_dump" എന്നീ സൗകര്യങ്ങൾ ഉപയോഗിക്കാം
പ്രൊഫൈൽ ശേഖരണം താൽപ്പര്യമുള്ള പ്രോഗ്രാം മേഖലയിലേക്ക് പരിമിതപ്പെടുത്തുക. "_gcov_reset(void)" എന്ന് വിളിക്കുന്നു
എല്ലാ പ്രൊഫൈൽ കൗണ്ടറുകളും പൂജ്യത്തിലേക്ക് മായ്ക്കും, കൂടാതെ "_gcov_dump(void)" എന്ന് വിളിക്കുന്നത്
ആ ഘട്ടത്തിൽ ശേഖരിച്ച പ്രൊഫൈൽ വിവരങ്ങൾ ഡംപ് ചെയ്യണം .gcda ഔട്ട്പുട്ട് ഫയലുകൾ.

onworks.net സേവനങ്ങൾ ഉപയോഗിച്ച് powerpc64-linux-gnu-gcov ഓൺലൈനായി ഉപയോഗിക്കുക