m68k-linux-gnu-gcov-5 - क्लाउड में ऑनलाइन

कार्यक्रम:

नाम

gcov - कवरेज परीक्षण उपकरण

SYNOPSIS

जीसीओवी [-v|--संस्करण] [-h|--मदद]
[-a|--ऑल-ब्लॉक]
[-b|--शाखा संभावना]
[-c|--शाखा-गणना]
[-d|--प्रदर्शन-प्रगति]
[-f|--फंक्शन-सारांश]
[-i|--मध्यवर्ती-प्रारूप]
[-l|--लॉन्ग-फाइल-नाम]
[-m|--विघटित-नाम]
[-n|--उत्पादन नही]
[-o|--वस्तु-निर्देशिका निर्देशिका|फ़ाइल]
[-p|--संरक्षित-पथ]
[-r|--सापेक्ष-केवल]
[-s|--स्रोत-उपसर्ग डायरेक्टरी]
[-u|--बिना शर्त शाखा]
फ़ाइलों

वर्णन

जीसीओवी एक परीक्षण कवरेज कार्यक्रम है। अपने कार्यक्रमों का विश्लेषण करने के लिए जीसीसी के साथ मिलकर इसका उपयोग करें
अधिक कुशल, तेजी से चलने वाला कोड बनाने और अपने के अप्रयुक्त भागों को खोजने में मदद करें
कार्यक्रम। आप उपयोग कर सकते हैं जीसीओवी एक प्रोफाइलिंग टूल के रूप में यह पता लगाने में सहायता के लिए कि आपका अनुकूलन कहां है
प्रयास आपके कोड को सर्वोत्तम रूप से प्रभावित करेंगे। आप भी उपयोग कर सकते हैं जीसीओवी अन्य प्रोफाइलिंग के साथ
उपकरण, ग्प्रोफ, यह आकलन करने के लिए कि आपके कोड के कौन से हिस्से कंप्यूटिंग समय की सबसे बड़ी मात्रा का उपयोग करते हैं।

प्रोफाइलिंग टूल आपको अपने कोड के प्रदर्शन का विश्लेषण करने में मदद करते हैं। जैसे प्रोफाइलर का उपयोग करना जीसीओवी
or ग्प्रोफ, आप कुछ बुनियादी प्रदर्शन आंकड़े ढूंढ सकते हैं, जैसे:

* कोड की प्रत्येक पंक्ति कितनी बार निष्पादित होती है

* कोड की कौन सी पंक्तियाँ वास्तव में निष्पादित की जाती हैं

* कोड का प्रत्येक खंड कितना कंप्यूटिंग समय उपयोग करता है

एक बार जब आप इन चीजों को जान लेते हैं कि संकलित होने पर आपका कोड कैसे काम करता है, तो आप प्रत्येक को देख सकते हैं
मॉड्यूल यह देखने के लिए कि कौन से मॉड्यूल को अनुकूलित किया जाना चाहिए। जीसीओवी आपको यह निर्धारित करने में मदद करता है कि कहां काम करना है
अनुकूलन पर।

सॉफ़्टवेयर डेवलपर भी यह सुनिश्चित करने के लिए परीक्षण सूट के साथ मिलकर कवरेज परीक्षण का उपयोग करते हैं
सॉफ्टवेयर वास्तव में रिलीज के लिए काफी अच्छा है। टेस्टसुइट सत्यापित कर सकते हैं कि एक प्रोग्राम
अपेक्षा के अनुरूप काम करता है; एक कवरेज कार्यक्रम यह देखने के लिए परीक्षण करता है कि कार्यक्रम का कितना प्रयोग किया जाता है
परीक्षण सूट। डेवलपर तब यह निर्धारित कर सकते हैं कि किस प्रकार के परीक्षण मामलों को जोड़ने की आवश्यकता है
बेहतर परीक्षण और बेहतर अंतिम उत्पाद दोनों बनाने के लिए परीक्षण सूट।

यदि आप उपयोग करने की योजना बना रहे हैं तो आपको अनुकूलन के बिना अपना कोड संकलित करना चाहिए जीसीओवी क्योंकि
ऑप्टिमाइज़ेशन, कोड की कुछ पंक्तियों को एक फ़ंक्शन में जोड़कर, आपको उतना नहीं दे सकता है
जानकारी के रूप में आपको 'हॉट स्पॉट' की तलाश करने की आवश्यकता है जहां कोड बहुत अधिक उपयोग कर रहा है
कंप्यूटर समय। इसी तरह, क्योंकि जीसीओवी लाइन द्वारा आंकड़े जमा करता है (सबसे कम . पर)
रिज़ॉल्यूशन), यह प्रोग्रामिंग शैली के साथ सबसे अच्छा काम करता है जो प्रत्येक पर केवल एक कथन रखता है
रेखा। यदि आप जटिल मैक्रोज़ का उपयोग करते हैं जो लूप या अन्य नियंत्रण संरचनाओं तक विस्तृत होते हैं,
आंकड़े कम सहायक होते हैं---वे केवल उस लाइन पर रिपोर्ट करते हैं जहां मैक्रो कॉल
दिखाई पड़ना। यदि आपके जटिल मैक्रोज़ फ़ंक्शन की तरह व्यवहार करते हैं, तो आप उन्हें इनलाइन से बदल सकते हैं
इस समस्या को हल करने के लिए कार्य करता है।

जीसीओवी नामक एक लॉगफाइल बनाता है Sourcefile.gcov जो इंगित करता है कि . की प्रत्येक पंक्ति कितनी बार
एक स्रोत फ़ाइल Sourcefile.c निष्पादित किया है। आप इन लॉगफाइल्स का उपयोग इसके साथ कर सकते हैं ग्प्रोफ सेवा मेरे
आपके कार्यक्रमों के प्रदर्शन को ठीक करने में सहायता। ग्प्रोफ आपको समय की जानकारी देता है
आप से प्राप्त जानकारी के साथ उपयोग कर सकते हैं जीसीओवी.

जीसीओवी केवल जीसीसी के साथ संकलित कोड पर काम करता है। यह किसी अन्य प्रोफाइलिंग के साथ संगत नहीं है
या परीक्षण कवरेज तंत्र।

विकल्प

-h
--मदद
उपयोग करने के बारे में सहायता प्रदर्शित करें जीसीओवी (मानक आउटपुट पर), और बिना कुछ किए बाहर निकलें
आगे की प्रक्रिया।

-v
--संस्करण
प्रदर्शित करें जीसीओवी संस्करण संख्या (मानक आउटपुट पर), और बिना कुछ किए बाहर निकलें
आगे की प्रक्रिया।

-a
--ऑल-ब्लॉक
प्रत्येक मूल ब्लॉक के लिए अलग-अलग निष्पादन गणना लिखें। आम तौर पर gcov आउटपुट
निष्पादन केवल एक पंक्ति के मुख्य ब्लॉक के लिए गिना जाता है। इस विकल्प के साथ आप कर सकते हैं
निर्धारित करें कि क्या एक पंक्ति के भीतर ब्लॉक निष्पादित नहीं किए जा रहे हैं।

-b
--शाखा संभावना
आउटपुट फ़ाइल में शाखा आवृत्तियों को लिखें, और शाखा सारांश जानकारी लिखें
मानक आउटपुट। यह विकल्प आपको यह देखने की अनुमति देता है कि आपके कार्यक्रम में प्रत्येक शाखा कितनी बार है
लिया गया। बिना शर्त शाखाएं नहीं दिखाई जाएंगी, जब तक कि -u विकल्प दिया गया है।

-c
--शाखा-गणना
शाखा आवृत्तियों को प्रतिशत के बजाय ली गई शाखाओं की संख्या के रूप में लिखें
ली गई शाखाओं की।

-n
--उत्पादन नही
नहीं बनाएँ जीसीओवी निर्गम संचिका।

-l
--लॉन्ग-फाइल-नाम
शामिल स्रोत फ़ाइलों के लिए लंबे फ़ाइल नाम बनाएँ। उदाहरण के लिए, यदि हेडर फ़ाइल xh
कोड शामिल है, और फ़ाइल में शामिल किया गया था एसी, फिर दौड़ना जीसीओवी फ़ाइल पर एसी
नामक एक आउटपुट फ़ाइल का उत्पादन करेगा एसी##xhgcov के बजाय xhgcov। यह हो सकता है
उपयोगी अगर xh एकाधिक स्रोत फ़ाइलों में शामिल है और आप व्यक्ति को देखना चाहते हैं
योगदान। यदि आप का उपयोग करते हैं -p विकल्प, दोनों सहित और फ़ाइल नाम शामिल हैं
पूर्ण पथ नाम होंगे।

-p
--संरक्षित-पथ
जनरेट के नाम से पूरी पथ सूचना सुरक्षित रखें .gcov फ़ाइलें। के बग़ैर
यह विकल्प, केवल फ़ाइल नाम घटक का उपयोग किया जाता है। इस विकल्प के साथ, सभी निर्देशिका
उपयोग किया जाता है, के साथ / में अनुवादित वर्ण # वर्ण, . निर्देशिका घटक हटा दिए गए
और हटाने योग्य .. घटकों का नाम बदलकर . कर दिया गया ^. यह उपयोगी है अगर सोर्सफाइल्स अंदर हैं
कई अलग निर्देशिका।

-r
--सापेक्ष-केवल
संबंधित पथनाम वाली स्रोत फ़ाइलों के बारे में केवल आउटपुट जानकारी (स्रोत के बाद
उपसर्ग elision)। निरपेक्ष पथ आमतौर पर सिस्टम हेडर फाइलें और किसी का कवरेज होते हैं
उसमें इनलाइन फ़ंक्शन सामान्य रूप से रुचिकर नहीं होते हैं।

-f
--फंक्शन-सारांश
फ़ाइल स्तर सारांश के अतिरिक्त प्रत्येक फ़ंक्शन के लिए आउटपुट सारांश।

-o निर्देशिका|फ़ाइल
--वस्तु-निर्देशिका डायरेक्टरी
--वस्तु-फ़ाइल पट्टिका
या तो निर्देशिका निर्दिष्ट करें जिसमें gcov डेटा फ़ाइलें हों, या ऑब्जेक्ट पथ नाम निर्दिष्ट करें।
RSI .gcno, तथा .gcda डेटा फ़ाइलें इस विकल्प का उपयोग करने के लिए खोजी जाती हैं। यदि कोई निर्देशिका है
निर्दिष्ट, डेटा फ़ाइलें उस निर्देशिका में हैं और इनपुट फ़ाइल नाम के नाम पर हैं,
इसके विस्तार के बिना। यदि कोई फ़ाइल यहाँ निर्दिष्ट की जाती है, तो डेटा फ़ाइलों का नाम इसके नाम पर रखा जाता है
वह फ़ाइल, उसके एक्सटेंशन के बिना।

-s डायरेक्टरी
--स्रोत-उपसर्ग डायरेक्टरी
आउटपुट कवरेज फ़ाइलें जनरेट करते समय निकालने के लिए स्रोत फ़ाइल नामों के लिए एक उपसर्ग।
एक अलग निर्देशिका में निर्माण करते समय यह विकल्प उपयोगी होता है, और पथनाम
स्रोत निर्देशिका आउटपुट फ़ाइल नाम निर्धारित करते समय नहीं चाहता है। ध्यान दें कि यह
स्रोत फ़ाइल निरपेक्ष है या नहीं यह निर्धारित करने से पहले उपसर्ग का पता लगाना लागू किया जाता है।

-u
--बिना शर्त शाखा
जब शाखा संभावनाएं दी जाती हैं, तो बिना शर्त शाखाओं को शामिल करें।
बिना शर्त शाखाएं आम तौर पर दिलचस्प नहीं होती हैं।

-d
--प्रदर्शन-प्रगति
मानक आउटपुट पर प्रगति प्रदर्शित करें।

-i
--मध्यवर्ती-प्रारूप
एक आसान-से-पार्स इंटरमीडिएट टेक्स्ट प्रारूप में आउटपुट gcov फ़ाइल जिसका उपयोग किया जा सकता है एलसीओवी
या अन्य उपकरण। आउटपुट सिंगल है .gcov फ़ाइल प्रति .gcda फ़ाइल। कोई स्रोत कोड नहीं है
आवश्यक.

इंटरमीडिएट का प्रारूप .gcov फ़ाइल प्रति पंक्ति एक प्रविष्टि के साथ सादा पाठ है

फ़ाइल:
समारोह: , ,
गिनती: ,
डाली: ,

जहां है
नोटेक्सेक (शाखा निष्पादित नहीं)
लिया (शाखा निष्पादित और लिया गया)
नहीं लिया गया (शाखा निष्पादित, लेकिन नहीं ली गई)

कई हो सकते हैं मध्यवर्ती 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 फ़ाइल प्रत्येक स्रोत के लिए तैयार की जाती है (या
हेडर) फ़ाइल जिसमें कोड होता है, जिसे डेटा फ़ाइलों का उत्पादन करने के लिए संकलित किया गया था। NS
मैंगल्डनाम आउटपुट फ़ाइल नाम का हिस्सा आमतौर पर केवल स्रोत फ़ाइल नाम होता है, लेकिन कर सकते हैं
कुछ और जटिल हो अगर -l or -p विकल्प दिए गए हैं। उन विकल्पों का संदर्भ लें
ब्योरा हेतु।

यदि आप आह्वान करते हैं जीसीओवी कई इनपुट फाइलों के साथ, प्रत्येक इनपुट फाइल से योगदान हैं
संक्षेप। आम तौर पर आप इसे फाइलों की उसी सूची के साथ बुलाएंगे जो अंतिम लिंक के रूप में है
आपका निष्पादन योग्य।

RSI .gcov फ़ाइलें शामिल हैं : प्रोग्राम सोर्स कोड के साथ अलग किए गए फ़ील्ड। प्रारूप
is

: :

कमांड लाइन विकल्प द्वारा अनुरोध किए जाने पर अतिरिक्त ब्लॉक जानकारी प्रत्येक पंक्ति में सफल हो सकती है।
RSI निष्पादन_गिनती is - बिना कोड वाली लाइनों के लिए। गैर-निष्पादित लाइनें चिह्नित हैं #####
or ====, इस पर निर्भर करता है कि वे गैर-असाधारण रास्तों से पहुंच योग्य हैं या केवल
असाधारण पथ जैसे सी ++ अपवाद हैंडलर, क्रमशः।

शुरुआत में जानकारी की कुछ पंक्तियाँ हैं रेखा संख्या शून्य का। ये प्रस्तावना पंक्तियाँ हैं
फार्म का

-:0: :

इन प्रस्तावना पंक्तियों के क्रम और संख्या को इस प्रकार बढ़ाया जाएगा जीसीओवी विकास
प्रगति --- अपरिवर्तित शेष उन पर भरोसा न करें। उपयोग टैग किसी विशेष का पता लगाने के लिए
प्रस्तावना पंक्ति।

अतिरिक्त ब्लॉक जानकारी फॉर्म की है



RSI करें- मानव पठनीय है, लेकिन मशीन पार्सिंग के लिए काफी सरल होने के लिए डिज़ाइन किया गया है
भी है.

प्रतिशत प्रिंट करते समय, 0% और 100% केवल तभी मुद्रित होते हैं जब मान होते हैं ठीक ठीक 0% और
क्रमशः 100%। अन्य मान जिन्हें परंपरागत रूप से 0% या 100% तक पूर्णांकित किया जाएगा, वे हैं
इसके बजाय निकटतम गैर-सीमा मान के रूप में मुद्रित किया गया।

उपयोग करते समय जीसीओवी, आपको पहले अपने प्रोग्राम को दो विशेष GCC विकल्पों के साथ संकलित करना होगा:
-फ्रोफाइल-आर्क्स -फटेस्ट-कवरेज. यह संकलक को अतिरिक्त उत्पन्न करने के लिए कहता है
gcov द्वारा आवश्यक जानकारी (मूल रूप से कार्यक्रम का एक प्रवाह ग्राफ) और इसमें शामिल है
आवश्यक अतिरिक्त प्रोफाइलिंग जानकारी उत्पन्न करने के लिए ऑब्जेक्ट फ़ाइलों में अतिरिक्त कोड
जीसीओवी द्वारा इन अतिरिक्त फ़ाइलों को उस निर्देशिका में रखा जाता है जहाँ ऑब्जेक्ट फ़ाइल है
स्थित है.

प्रोग्राम चलाने से प्रोफाइल आउटपुट जेनरेट होगा। प्रत्येक स्रोत फ़ाइल के लिए
के साथ संकलित -फ्रोफाइल-आर्क्स, एक साथ .gcda फ़ाइल को ऑब्जेक्ट फ़ाइल में रखा जाएगा
निर्देशिका.

रनिंग जीसीओवी आपके प्रोग्राम के स्रोत फ़ाइल नामों के साथ तर्क के रूप में अब एक सूची तैयार होगी
प्रत्येक पंक्ति के लिए निष्पादन की आवृत्ति के साथ कोड का। उदाहरण के लिए, यदि आपका प्रोग्राम
कहा जाता है टीएमपी.सी, जब आप मूल का उपयोग करते हैं तो आप यही देखते हैं जीसीओवी सुविधा:

$ gcc -fprofile-arcs -ftest-कवरेज tmp.c
$ ए.आउट
$ जीसीओवी tmp.c
फ़ाइल tmp.c . में निष्पादित 90.00 स्रोत लाइनों में से 10%
tmp.c.gcov बनाना।

फ़ाइल tmp.c.gcov से आउटपुट शामिल है जीसीओवी। यहाँ एक नमूना है:

-: 0: स्रोत: tmp.c
-: 0: ग्राफ: tmp.gcno
-: 0: डेटा: tmp.gcda
-: 0: रन: 1
-: 0: कार्यक्रम: 1
-: 1:#शामिल करें
-: 2:
-: 3: इंट मेन (शून्य)
1: 4: {
1: 5: इंट आई, टोटल;
-: 6:
1:7: कुल = 0;
-: 8:
11:9: के लिए (i = 0; i <10; i++)
10: 10: कुल += मैं;
-: 11:
1:12: यदि (कुल != 45)
#####: 13: प्रिंटफ ("विफलता\n");
-: 14: अन्य
1: 15: प्रिंटफ ("सफलता \ n");
1: 16: वापसी 0;
-: 17:}

जब आप उपयोग करते हैं -a विकल्प, आपको अलग-अलग ब्लॉक काउंट मिलेंगे, और आउटपुट दिखता है
इस तरह:

-: 0: स्रोत: tmp.c
-: 0: ग्राफ: tmp.gcno
-: 0: डेटा: tmp.gcda
-: 0: रन: 1
-: 0: कार्यक्रम: 1
-: 1:#शामिल करें
-: 2:
-: 3: इंट मेन (शून्य)
1: 4: {
1: 4-ब्लॉक 0
1: 5: इंट आई, टोटल;
-: 6:
1:7: कुल = 0;
-: 8:
11:9: के लिए (i = 0; i <10; i++)
11: 9-ब्लॉक 0
10: 10: कुल += मैं;
10: 10-ब्लॉक 0
-: 11:
1:12: यदि (कुल != 45)
1: 12-ब्लॉक 0
#####: 13: प्रिंटफ ("विफलता\n");
$$$$$: 13-ब्लॉक 0
-: 14: अन्य
1: 15: प्रिंटफ ("सफलता \ n");
1: 15-ब्लॉक 0
1: 16: वापसी 0;
1: 16-ब्लॉक 0
-: 17:}

इस मोड में, प्रत्येक मूल ब्लॉक केवल एक पंक्ति पर दिखाया जाता है - ब्लॉक की अंतिम पंक्ति। ए
बहु-पंक्ति ब्लॉक केवल उस अंतिम पंक्ति की निष्पादन गणना में योगदान देगा, और अन्य
लाइनों में कोड नहीं दिखाया जाएगा, जब तक कि पिछले ब्लॉक उन पंक्तियों पर समाप्त नहीं हो जाते। NS
एक पंक्ति की कुल निष्पादन संख्या दिखाई जाती है और बाद की पंक्तियाँ निष्पादन की संख्या दिखाती हैं
उस लाइन पर समाप्त होने वाले अलग-अलग ब्लॉकों के लिए। प्रत्येक ब्लॉक के बाद, शाखा और कॉल मायने रखता है
ब्लॉक का दिखाया जाएगा, यदि -b विकल्प दिया गया है।

जीसीसी उपकरण जिस तरह से कॉल करते हैं, उसके कारण कॉल की संख्या को नंबर वाली लाइन के बाद दिखाया जा सकता है
व्यक्तिगत ब्लॉक। जैसा कि आप देख सकते हैं, लाइन 13 में एक मूल ब्लॉक है जिसे निष्पादित नहीं किया गया था।

जब आप उपयोग करते हैं -b विकल्प, आपका आउटपुट इस तरह दिखता है:

$ gcov -b tmp.c
फ़ाइल tmp.c . में निष्पादित 90.00 स्रोत लाइनों में से 10%
फ़ाइल tmp.c . में निष्पादित 80.00 शाखाओं में से 5%
80.00 शाखाओं में से 5% कम से कम एक बार फ़ाइल tmp.c . में ली गई हैं
फ़ाइल tmp.c . में निष्पादित 50.00 कॉलों में से 2%
tmp.c.gcov बनाना।

यहाँ एक परिणामी का एक नमूना है tmp.c.gcov फ़ाइल:

-: 0: स्रोत: tmp.c
-: 0: ग्राफ: tmp.gcno
-: 0: डेटा: tmp.gcda
-: 0: रन: 1
-: 0: कार्यक्रम: 1
-: 1:#शामिल करें
-: 2:
-: 3: इंट मेन (शून्य)
फ़ंक्शन मुख्य जिसे 1 कहा जाता है, 1 ब्लॉकों को निष्पादित किया जाता है 75%
1: 4: {
1: 5: इंट आई, टोटल;
-: 6:
1:7: कुल = 0;
-: 8:
11:9: के लिए (i = 0; i <10; i++)
शाखा 0 ने 91% लिया (गिरावट)
शाखा 1 ने 9% लिया
10: 10: कुल += मैं;
-: 11:
1:12: यदि (कुल != 45)
शाखा 0 ने 0% लिया (गिरावट)
शाखा 1 ने 100% लिया
#####: 13: प्रिंटफ ("विफलता\n");
कॉल 0 कभी निष्पादित नहीं किया गया
-: 14: अन्य
1: 15: प्रिंटफ ("सफलता \ n");
कॉल 0 को 1 कॉल किया गया 100% लौटा
1: 16: वापसी 0;
-: 17:}

प्रत्येक फ़ंक्शन के लिए, एक लाइन मुद्रित की जाती है जिसमें दिखाया जाता है कि फ़ंक्शन को कितनी बार कॉल किया जाता है, कैसे
कई बार यह वापस आता है और फ़ंक्शन के कितने प्रतिशत ब्लॉक निष्पादित किए गए थे।

प्रत्येक मूल ब्लॉक के लिए, मूल ब्लॉक की अंतिम पंक्ति का वर्णन करने के बाद एक पंक्ति मुद्रित की जाती है
वह शाखा या कॉल जो मूल ब्लॉक को समाप्त करती है। कई शाखाएँ और कॉल हो सकते हैं
एकल स्रोत लाइन के लिए सूचीबद्ध है यदि उस लाइन पर समाप्त होने वाले कई बुनियादी ब्लॉक हैं।
इस मामले में, शाखाओं और कॉलों में से प्रत्येक को एक नंबर दिया जाता है। कोई आसान तरीका नहीं है
इन शाखाओं को मैप करें और स्रोत निर्माण पर वापस कॉल करें। सामान्य तौर पर, हालांकि, सबसे कम
क्रमांकित शाखा या कॉल स्रोत लाइन पर सबसे बाईं ओर के निर्माण के अनुरूप होगी।

एक शाखा के लिए, यदि इसे कम से कम एक बार निष्पादित किया गया था, तो प्रतिशत की संख्या को दर्शाता है
शाखा को कितनी बार निष्पादित किया गया था, कितनी बार शाखा को विभाजित किया गया था
मुद्रित। अन्यथा, "कभी निष्पादित नहीं" संदेश मुद्रित होता है।

एक कॉल के लिए, यदि इसे कम से कम एक बार निष्पादित किया गया था, तो प्रतिशत की संख्या को दर्शाता है
कितनी बार कॉल लौटाई गई कॉल को निष्पादित किए जाने की संख्या से विभाजित किया जाएगा
मुद्रित। यह आमतौर पर 100% होगा, लेकिन "बाहर निकलें" या . कॉल करने वाले कार्यों के लिए कम हो सकता है
"longjmp", और इस प्रकार हर बार उन्हें बुलाए जाने पर वापस नहीं आ सकता है।

निष्पादन गणना संचयी हैं। यदि उदाहरण कार्यक्रम को बिना के फिर से निष्पादित किया गया था
निकाल रहा है .gcda फ़ाइल, स्रोत में प्रत्येक पंक्ति की संख्या के लिए गिनती थी
निष्पादित पिछले रन के परिणामों में जोड़ा जाएगा। यह संभावित रूप से उपयोगी है
कई मायनों में। उदाहरण के लिए, इसका उपयोग कई से अधिक डेटा जमा करने के लिए किया जा सकता है
कार्यक्रम एक परीक्षण सत्यापन सूट के हिस्से के रूप में चलता है, या अधिक सटीक दीर्घकालिक प्रदान करने के लिए
बड़ी संख्या में चल रहे कार्यक्रमों की जानकारी।

में डेटा .gcda प्रोग्राम से बाहर निकलने से ठीक पहले फ़ाइलें सहेजी जाती हैं। प्रत्येक के लिए
स्रोत फ़ाइल के साथ संकलित -फ्रोफाइल-आर्क्स, प्रोफाइलिंग कोड पहले a . में पढ़ने का प्रयास करता है
मौजूदा .gcda फ़ाइल; अगर फ़ाइल निष्पादन योग्य से मेल नहीं खाती है (मूल की भिन्न संख्या
ब्लॉक मायने रखता है) यह फ़ाइल की सामग्री को अनदेखा कर देगा। यह फिर नए निष्पादन में जोड़ता है
मायने रखता है और अंत में फ़ाइल को डेटा लिखता है।

का प्रयोग जीसीओवी साथ में जीसीसी इष्टतमीकरण

यदि आप उपयोग करने की योजना बनाते हैं जीसीओवी अपने कोड को अनुकूलित करने में सहायता के लिए, आपको पहले अपने प्रोग्राम को संकलित करना होगा
दो विशेष जीसीसी विकल्पों के साथ: -फ्रोफाइल-आर्क्स -फटेस्ट-कवरेज. इसके अलावा, आप कर सकते हैं
किसी अन्य GCC विकल्प का उपयोग करें; लेकिन अगर आप यह साबित करना चाहते हैं कि आपके कार्यक्रम की हर एक पंक्ति
निष्पादित किया गया था, आपको उसी समय अनुकूलन के साथ संकलन नहीं करना चाहिए। कुछ मशीनों पर
अनुकूलक कुछ सरल कोड लाइनों को अन्य लाइनों के साथ जोड़कर समाप्त कर सकता है।
उदाहरण के लिए, इस तरह कोड:

अगर (ए! = बी)
सी = 1;
अन्य
सी = 0;

कुछ मशीनों पर एक निर्देश में संकलित किया जा सकता है। इस मामले में, कोई रास्ता नहीं है
जीसीओवी प्रत्येक पंक्ति के लिए अलग निष्पादन गणना की गणना करने के लिए क्योंकि अलग नहीं है
प्रत्येक पंक्ति के लिए कोड। इसलिए जीसीओवी यदि आप प्रोग्राम को संकलित करते हैं तो आउटपुट इस तरह दिखता है
अनुकूलन के साथ:

100: 12: अगर (ए! = बी)
100: 13: सी = 1;
100: 14: अन्य
100: 15: सी = 0;

आउटपुट से पता चलता है कि कोड का यह ब्लॉक, अनुकूलन द्वारा संयुक्त, 100 बार निष्पादित किया गया।
एक मायने में यह परिणाम सही है, क्योंकि केवल एक ही निर्देश का प्रतिनिधित्व कर रहा था
इन चारों पंक्तियों में। हालांकि, आउटपुट यह नहीं दर्शाता है कि परिणाम कितनी बार है
0 था और कितनी बार परिणाम 1 था।

इनलाइन करने योग्य फ़ंक्शन अनपेक्षित लाइन काउंट बना सकते हैं। लाइन काउंट के लिए दिखाए गए हैं
इनलाइन करने योग्य फ़ंक्शन का स्रोत कोड, लेकिन जो दिखाया गया है वह इस बात पर निर्भर करता है कि फ़ंक्शन कहां है
इनलाइन किया गया है, या यदि यह बिल्कुल भी इनलाइन नहीं है।

यदि फ़ंक्शन इनलाइन नहीं है, तो कंपाइलर को की एक आउट ऑफ लाइन कॉपी का उत्सर्जन करना चाहिए
फ़ंक्शन, किसी भी ऑब्जेक्ट फ़ाइल में जिसे इसकी आवश्यकता होती है। अगर फ़ाइलए.ओ और फ़ाइलबीओ दोनों में से बाहर है
किसी विशेष इनलाइन करने योग्य फ़ंक्शन के लाइन निकाय, दोनों में कवरेज भी होगा
उस समारोह के लिए मायने रखता है। कब फ़ाइलए.ओ और फ़ाइलबीओ एक साथ जुड़े हुए हैं, लिंकर होगा,
कई प्रणालियों पर, उस फ़ंक्शन की सभी कॉलों के लिए आउट ऑफ़ लाइन निकायों में से किसी एक का चयन करें,
और दूसरे को हटा दें या अनदेखा करें। दुर्भाग्य से, यह कवरेज काउंटरों को नहीं हटाएगा
अप्रयुक्त फ़ंक्शन बॉडी के लिए। इसलिए जब वाद्य यंत्र लगाया जाता है, तो उस फ़ंक्शन का एक ही उपयोग होता है
शून्य गिनती दिखाएगा।

यदि फ़ंक्शन कई स्थानों पर इनलाइन है, तो प्रत्येक स्थान में ब्लॉक संरचना हो सकती है
समान नहीं होना। उदाहरण के लिए, एक शर्त अब संकलन समय पर गणना योग्य हो सकती है
कुछ उदाहरण। क्योंकि इनलाइन फ़ंक्शन के सभी उपयोगों का कवरेज दिखाया जाएगा
एक ही स्रोत पंक्तियों के लिए, रेखा की गणना स्वयं असंगत लग सकती है।

लंबे समय से चल रहे एप्लिकेशन "_gcov_reset" और "_gcov_dump" सुविधाओं का उपयोग कर सकते हैं
प्रोफ़ाइल संग्रह को रुचि के कार्यक्रम क्षेत्र तक सीमित रखें। कॉल करना "_gcov_reset(void)"
सभी प्रोफ़ाइल काउंटरों को शून्य पर साफ़ कर देगा, और "_gcov_dump(void)" को कॉल करने से
उस बिंदु पर एकत्र की गई प्रोफ़ाइल जानकारी को डंप किया जाना है .gcda आउटपुट फ़ाइलें।

onworks.net सेवाओं का उपयोग करके m68k-linux-gnu-gcov-5 का ऑनलाइन उपयोग करें