aarch64-linux-gnu-gcov - En ligne dans le cloud

PROGRAMME:

Nom

gcov - outil de test de couverture

SYNOPSIS

gcov [-v|--version] [-h|--Aidez-moi]
[-a|--tous les blocs]
[-b|--branch-probabilites]
[-c|--nombre de branches]
[-d|--display-progression]
[-f|--fonction-résumés]
[-i|--format-intermédiaire]
[-l|--noms-de-fichiers-longs]
[-m|--noms-démêlés]
[-n|--aucune sortie]
[-o|--répertoire-objet répertoire|fichier]
[-p|--preserve-chemins]
[-r|--relatif uniquement]
[-s|--préfixe-source annuaire]
[-u|--branches-inconditionnelles]
fichiers

DESCRIPTION

gcov est un programme de couverture de test. Utilisez-le de concert avec GCC pour analyser vos programmes afin de
aider à créer un code d'exécution plus efficace et plus rapide et à découvrir des parties non testées de votre
programme. Vous pouvez utiliser gcov comme outil de profilage pour aider à découvrir où votre optimisation
les efforts affecteront le mieux votre code. Vous pouvez aussi utiliser gcov avec les autres profils
outil, gprof, pour évaluer quelles parties de votre code utilisent le plus de temps de calcul.

Les outils de profilage vous aident à analyser les performances de votre code. Utiliser un profileur tel que gcov
or gprof, vous pouvez découvrir quelques statistiques de performances de base, telles que :

* à quelle fréquence chaque ligne de code s'exécute

* quelles lignes de code sont réellement exécutées

* combien de temps de calcul chaque section de code utilise

Une fois que vous savez ces choses sur la façon dont votre code fonctionne une fois compilé, vous pouvez regarder chaque
module pour voir quels modules doivent être optimisés. gcov vous aide à déterminer où travailler
sur l'optimisation.

Les développeurs de logiciels utilisent également des tests de couverture de concert avec des suites de tests, pour s'assurer
le logiciel est en fait assez bon pour une version. Les suites de tests peuvent vérifier qu'un programme
fonctionne comme prévu ; un programme de couverture teste pour voir quelle part du programme est exercée par
la suite de tests. Les développeurs peuvent ensuite déterminer quels types de cas de test doivent être ajoutés à
les suites de tests pour créer à la fois de meilleurs tests et un meilleur produit final.

Vous devez compiler votre code sans optimisation si vous prévoyez d'utiliser gcov parce que le
l'optimisation, en combinant quelques lignes de code en une seule fonction, peut ne pas vous donner autant
informations car vous devez rechercher les « points chauds » où le code utilise beaucoup de
temps informatique. De même, parce que gcov cumule les statistiques par ligne (au plus bas
résolution), cela fonctionne mieux avec un style de programmation qui place une seule instruction sur chaque
ligne. Si vous utilisez des macros compliquées qui s'étendent aux boucles ou à d'autres structures de contrôle,
les statistiques sont moins utiles --- elles ne rapportent que sur la ligne où l'appel de macro
apparaît. Si vos macros complexes se comportent comme des fonctions, vous pouvez les remplacer par des inline
fonctions pour résoudre ce problème.

gcov crée un fichier journal appelé fichiersource.gcov qui indique combien de fois chaque ligne de
un fichier source fichiersource.c a exécuté. Vous pouvez utiliser ces fichiers journaux avec gprof à
aide à affiner les performances de vos programmes. gprof vous donne des informations de temps
pouvez utiliser avec les informations que vous obtenez de gcov.

gcov ne fonctionne que sur le code compilé avec GCC. Il n'est compatible avec aucun autre profilage
ou un mécanisme de couverture de test.

OPTIONS

-h
--Aidez-moi
Afficher l'aide sur l'utilisation gcov (sur la sortie standard), et quittez sans rien faire
traitement ultérieur.

-v
--version
Afficher le gcov numéro de version (sur la sortie standard), et quittez sans rien faire
traitement ultérieur.

-a
--tous les blocs
Écrivez des comptes d'exécution individuels pour chaque bloc de base. Normalement les sorties gcov
l'exécution ne compte que pour les blocs principaux d'une ligne. Avec cette option, vous pouvez
déterminer si les blocs d'une même ligne ne sont pas exécutés.

-b
--branch-probabilites
Écrivez les fréquences de branchement dans le fichier de sortie et écrivez les informations de résumé de branchement dans le
sortie standard. Cette option vous permet de voir à quelle fréquence chaque branche de votre programme
a été pris. Les branches inconditionnelles ne seront pas affichées, à moins que le -u option est donnée.

-c
--nombre de branches
Écrivez les fréquences de branchement comme le nombre de branchements pris, plutôt que le pourcentage
de branches prises.

-n
--aucune sortie
Ne créez pas le gcov fichier de sortie.

-l
--noms-de-fichiers-longs
Créez des noms de fichiers longs pour les fichiers source inclus. Par exemple, si le fichier d'en-tête xh
contient du code et a été inclus dans le fichier ca, puis en cours d'exécution gcov sur le fichier ca
produira un fichier de sortie appelé ac##xhgcov au lieu de xhgcov. Cela peut être
utile si xh est inclus dans plusieurs fichiers source et vous voulez voir l'individu
contributions. Si vous utilisez le -p option, les noms de fichiers inclus et inclus
seront des noms de chemin complets.

-p
--preserve-chemins
Conserver les informations de chemin complètes dans les noms des fichiers générés .gcov des dossiers. Sans
cette option, seul le composant de nom de fichier est utilisé. Avec cette option, tous les répertoires
sont utilisés, avec / caractères traduits en # personnages, . composants de répertoire supprimés
et inamovible .. composants renommés en ^. Ceci est utile si les fichiers source sont dans
plusieurs répertoires différents.

-r
--relatif uniquement
Afficher uniquement les informations sur les fichiers source avec un nom de chemin relatif (après la source
préfixe élision). Les chemins absolus sont généralement les fichiers d'en-tête du système et la couverture de tout
les fonctions en ligne y sont normalement inintéressantes.

-f
--fonction-résumés
Récapitulatifs de sortie pour chaque fonction en plus du récapitulatif au niveau du fichier.

-o répertoire|fichier
--répertoire-objet annuaire
--fichier-objet filet
Spécifiez soit le répertoire contenant les fichiers de données gcov, soit le nom du chemin de l'objet.
VOTRE .gcno et .gcda les fichiers de données sont recherchés à l'aide de cette option. Si un répertoire est
spécifié, les fichiers de données sont dans ce répertoire et nommés d'après le nom du fichier d'entrée,
sans son prolongement. Si un fichier est spécifié ici, les fichiers de données sont nommés d'après
ce fichier, sans son extension.

-s annuaire
--préfixe-source annuaire
Un préfixe pour les noms de fichiers source à supprimer lors de la génération des fichiers de couverture de sortie.
Cette option est utile lors de la construction dans un répertoire séparé, et le chemin d'accès au
Le répertoire source n'est pas souhaité lors de la détermination des noms de fichiers de sortie. Notez que ce
la détection de préfixe est appliquée avant de déterminer si le fichier source est absolu.

-u
--branches-inconditionnelles
Lorsque les probabilités de branchement sont données, incluez celles des branchements inconditionnels.
Les branches inconditionnelles ne sont normalement pas intéressantes.

-d
--display-progression
Affiche la progression sur la sortie standard.

-i
--format-intermédiaire
Fichier gcov de sortie dans un format de texte intermédiaire facile à analyser qui peut être utilisé par lcov
ou d'autres outils. La sortie est un seul .gcov fichier par .gcda déposer. Aucun code source n'est
nécessaire.

Le format de l'intermédiaire .gcov le fichier est en texte brut avec une entrée par ligne

déposer:
fonction: , ,
lcount : ,
branche: ,

Où le est
notexec (Branche non exécutée)
pris (Branche exécutée et prise)
nottaken (Branche exécutée, mais pas prise)

Il peut y avoir plusieurs entrées dans un gcov intermédiaire
déposer. Toutes les entrées suivant un se rapportent à ce fichier source
jusqu'à la prochaine entrée.

Voici un exemple quand -i est utilisé en conjonction avec -b option:

fichier : tableau.cc
fonction : 11,1,_Z3sumRKSt6vectorIPiSaIS0_EE
fonction:22,1,principale
lcount:11,1
lcount:12,1
lcount:14,1
branche:14,prise
lcount:26,1
branche : 28, non prise

-m
--noms-démêlés
Afficher les noms de fonction démêlés dans la sortie. La valeur par défaut est d'afficher la fonction mutilée
des noms.

gcov doit être exécuté avec le répertoire actuel le même que celui lorsque vous avez appelé le
compilateur. Sinon, il ne pourra pas localiser les fichiers sources. gcov produit des fichiers
appelé nom mutilé.gcov dans le répertoire courant. Ceux-ci contiennent les informations de couverture
du fichier source auquel ils correspondent. Une .gcov fichier est produit pour chaque source (ou
header) contenant le code, qui a été compilé pour produire les fichiers de données. Les
nom mutilé une partie du nom du fichier de sortie est généralement simplement le nom du fichier source, mais peut
être quelque chose de plus compliqué si le -l or -p les options sont données. Référez-vous à ces options
pour en savoir plus.

Si vous invoquez gcov avec plusieurs fichiers d'entrée, les contributions de chaque fichier d'entrée sont
additionné. En règle générale, vous l'invoquez avec la même liste de fichiers que le lien final de
votre exécutable.

VOTRE .gcov les fichiers contiennent le : champs séparés avec le code source du programme. Le format
is

: :

Des informations de bloc supplémentaires peuvent succéder à chaque ligne, lorsqu'elles sont demandées par l'option de ligne de commande.
VOTRE nombre_exécution is - pour les lignes ne contenant aucun code. Les lignes non exécutées sont marquées #####
or ====, selon qu'ils sont accessibles par des chemins non exceptionnels ou uniquement
chemins exceptionnels tels que les gestionnaires d'exceptions C++, respectivement.

Certaines lignes d'informations au départ ont numéro de ligne de zéro. Ces lignes de préambule sont
de la forme

-:0: :

L'ordre et le nombre de ces lignes de préambule seront augmentés au fur et à mesure gcov développant
progresse --- ne comptez pas sur eux pour qu'ils restent inchangés. Utilisation Étiquette pour localiser un particulier
ligne de préambule.

Les informations de bloc supplémentaires sont de la forme



VOTRE d'information est lisible par l'homme, mais conçu pour être assez simple pour l'analyse par machine
également.

Lors de l'impression des pourcentages, 0% et 100% ne sont imprimés que lorsque les valeurs sont exactement 0% et
100 % respectivement. D'autres valeurs qui seraient conventionnellement arrondies à 0 % ou 100 % sont
à la place imprimé comme la valeur non-limite la plus proche.

Lors de l'utilisation gcov, vous devez d'abord compiler votre programme avec deux options spéciales GCC :
-fprofile-arcs -ftest-couverture. Cela indique au compilateur de générer des
informations nécessaires à gcov (essentiellement un graphe de flux du programme) et comprend également
code supplémentaire dans les fichiers objets pour générer les informations de profilage supplémentaires nécessaires
par gcov. Ces fichiers supplémentaires sont placés dans le répertoire où se trouve le fichier objet
situé.

L'exécution du programme entraînera la génération d'une sortie de profil. Pour chaque fichier source
compilé avec -fprofile-arcs, un accompagnant .gcda le fichier sera placé dans le fichier objet
répertoire.

Fonctionnement gcov avec les noms de fichiers source de votre programme comme arguments produira maintenant une liste
du code ainsi que la fréquence d'exécution pour chaque ligne. Par exemple, si votre programme
est appelé tmp.c, c'est ce que vous voyez lorsque vous utilisez la base gcov établissement:

$ gcc -fprofile-arcs -ftest-couverture tmp.c
$ a.out
$ gcov tmp.c
90.00 % des 10 lignes sources exécutées dans le fichier tmp.c
Création de tmp.c.gcov.

Le fichier tmp.c.gcov contient la sortie de gcov. Voici un échantillon:

- : 0 : Source : tmp.c
-: 0:Graphique:tmp.gcno
-: 0:Données:tmp.gcda
- : 0 : courses : 1
- : 0 : Programmes : 1
- : 1 : #include
- : 2 :
- : 3:int principal (vide)
1 : 4 :{
1 : 5 : int i, total ;
- : 6 :
1 : 7 : total = 0 ;
- : 8 :
11 : 9 : pour (i = 0 ; i < 10 ; i++)
10 : 10 : total += i ;
- : 11 :
1 : 12 : si (total != 45)
##### : 13 : printf ("Échec\n");
- sinon
1 : 15 : printf ("Succès\n");
1 : 16 : renvoie 0 ;
- : 17 :}

Lorsque vous utilisez le -a option, vous obtiendrez des nombres de blocs individuels, et la sortie ressemble
comme ça:

- : 0 : Source : tmp.c
-: 0:Graphique:tmp.gcno
-: 0:Données:tmp.gcda
- : 0 : courses : 1
- : 0 : Programmes : 1
- : 1 : #include
- : 2 :
- : 3:int principal (vide)
1 : 4 :{
1: 4-bloc 0
1 : 5 : int i, total ;
- : 6 :
1 : 7 : total = 0 ;
- : 8 :
11 : 9 : pour (i = 0 ; i < 10 ; i++)
11: 9-bloc 0
10 : 10 : total += i ;
10: 10-bloc 0
- : 11 :
1 : 12 : si (total != 45)
1: 12-bloc 0
##### : 13 : printf ("Échec\n");
$$$$$ : 13 bloc 0
- sinon
1 : 15 : printf ("Succès\n");
1: 15-bloc 0
1 : 16 : renvoie 0 ;
1: 16-bloc 0
- : 17 :}

Dans ce mode, chaque bloc de base n'est affiché que sur une seule ligne -- la dernière ligne du bloc. UNE
bloc multiligne contribuera uniquement au nombre d'exécutions de cette dernière ligne, et d'autres
les lignes ne seront pas montrées comme contenant du code, à moins que les blocs précédents ne se terminent sur ces lignes. Les
le nombre total d'exécutions d'une ligne est affiché et les lignes suivantes affichent le nombre d'exécutions
pour les blocs individuels qui se terminent sur cette ligne. Après chaque bloc, la branche et l'appel comptent
du bloc sera affiché, si le -b option est donnée.

En raison de la façon dont GCC instrumente les appels, un nombre d'appels peut être affiché après une ligne sans
blocs individuels. Comme vous pouvez le voir, la ligne 13 contient un bloc de base qui n'a pas été exécuté.

Lorsque vous utilisez le -b option, votre sortie ressemble à ceci :

$ gcov -b tmp.c
90.00 % des 10 lignes sources exécutées dans le fichier tmp.c
80.00% des 5 branches exécutées dans le fichier tmp.c
80.00 % des 5 branches prises au moins une fois dans le fichier tmp.c
50.00 % des 2 appels exécutés dans le fichier tmp.c
Création de tmp.c.gcov.

Voici un exemple d'un résultat tmp.c.gcov fichier:

- : 0 : Source : tmp.c
-: 0:Graphique:tmp.gcno
-: 0:Données:tmp.gcda
- : 0 : courses : 1
- : 0 : Programmes : 1
- : 1 : #include
- : 2 :
- : 3:int principal (vide)
fonction main appelée 1 a renvoyé 1 blocs exécutés 75%
1 : 4 :{
1 : 5 : int i, total ;
- : 6 :
1 : 7 : total = 0 ;
- : 8 :
11 : 9 : pour (i = 0 ; i < 10 ; i++)
branche 0 prise 91% (fallthrough)
branche 1 prise 9%
10 : 10 : total += i ;
- : 11 :
1 : 12 : si (total != 45)
branche 0 prise 0% (fallthrough)
branche 1 prise 100%
##### : 13 : printf ("Échec\n");
appel 0 jamais exécuté
- sinon
1 : 15 : printf ("Succès\n");
appel 0 appelé 1 retourné 100%
1 : 16 : renvoie 0 ;
- : 17 :}

Pour chaque fonction, une ligne est imprimée indiquant combien de fois la fonction est appelée, comment
plusieurs fois, il retourne et quel pourcentage des blocs de la fonction ont été exécutés.

Pour chaque bloc de base, une ligne est imprimée après la dernière ligne du bloc de base décrivant
la branche ou l'appel qui termine le bloc de base. Il peut y avoir plusieurs branches et appels
répertorié pour une seule ligne source s'il y a plusieurs blocs de base qui se terminent sur cette ligne.
Dans ce cas, les branches et les appels reçoivent chacun un numéro. Il n'y a pas de moyen simple de
mapper ces branches et rappeler les constructions sources. En général, cependant, le plus bas
la branche ou l'appel numéroté correspondra à la construction la plus à gauche sur la ligne source.

Pour une branche, si elle a été exécutée au moins une fois, alors un pourcentage indiquant le nombre de
fois que la branche a été prise divisé par le nombre de fois où la branche a été exécutée sera
imprimé. Sinon, le message "jamais exécuté" est imprimé.

Pour un appel, s'il a été exécuté au moins une fois, alors un pourcentage indiquant le nombre de
fois l'appel retourné divisé par le nombre de fois où l'appel a été exécuté sera
imprimé. Ce sera généralement 100 %, mais peut être inférieur pour les fonctions qui appellent « exit » ou
"longjmp", et peut donc ne pas revenir à chaque appel.

Les comptes d'exécution sont cumulatifs. Si le programme d'exemple était exécuté à nouveau sans
suppression du .gcda fichier, le nombre de fois où chaque ligne de la source a été
exécutés seraient ajoutés aux résultats de la ou des exécutions précédentes. C'est potentiellement utile
de plusieurs manières. Par exemple, il pourrait être utilisé pour accumuler des données sur un certain nombre de
programme s'exécute dans le cadre d'une suite de vérification de test, ou pour fournir plus de précision à long terme
informations sur un grand nombre d'exécutions de programme.

Les données dans le .gcda les fichiers sont enregistrés juste avant la fermeture du programme. Pour chaque
fichier source compilé avec -fprofile-arcs, le code de profilage tente d'abord de lire dans un
existant .gcda déposer; si le fichier ne correspond pas à l'exécutable (nombre différent de fichiers de base
nombre de blocs), il ignorera le contenu du fichier. Il ajoute ensuite dans la nouvelle exécution
compte et écrit finalement les données dans le fichier.

En utilisant gcov avec GCC

Si vous prévoyez d'utiliser gcov pour aider à optimiser votre code, vous devez d'abord compiler votre programme
avec deux options spéciales GCC : -fprofile-arcs -ftest-couverture. A part ça, tu peux
utiliser toute autre option GCC ; mais si vous voulez prouver que chaque ligne de votre programme
a été exécuté, vous ne devez pas compiler avec optimisation en même temps. Sur certaines machines
l'optimiseur peut éliminer certaines lignes de code simples en les combinant avec d'autres lignes.
Par exemple, codez comme ceci :

si (a != b)
c = 1;
d'autre
c = 0;

peut être compilé en une seule instruction sur certaines machines. Dans ce cas, il n'y a aucun moyen de
gcov pour calculer des comptes d'exécution séparés pour chaque ligne car il n'y a pas de
code pour chaque ligne. D'où le gcov la sortie ressemble à ceci si vous avez compilé le programme
avec optimisation :

100 : 12 : si (a != b)
100 : 13 : c = 1 ;
100 : 14 : autre
100 : 15 : c = 0 ;

La sortie montre que ce bloc de code, combiné par optimisation, s'est exécuté 100 fois.
Dans un sens, ce résultat est correct, car il n'y avait qu'une seule instruction représentant
ces quatre lignes. Cependant, la sortie n'indique pas combien de fois le résultat
était 0 et combien de fois le résultat était 1.

Les fonctions inlineables peuvent créer des nombres de lignes inattendus. Le nombre de lignes est affiché pour le
code source de la fonction inlineable, mais ce qui est affiché dépend de l'endroit où se trouve la fonction
inline, ou s'il n'est pas inline du tout.

Si la fonction n'est pas en ligne, le compilateur doit émettre une copie hors ligne du
fonction, dans tout fichier objet qui en a besoin. Si fichierA.o et fichierB.o les deux contiennent sur
corps de ligne d'une fonction inlineable particulière, ils contiendront également tous les deux une couverture
compte pour cette fonction. Lorsque fichierA.o et fichierB.o sont liés entre eux, l'éditeur de liens,
sur de nombreux systèmes, sélectionnez l'un de ces corps hors ligne pour tous les appels à cette fonction,
et supprimer ou ignorer l'autre. Malheureusement, il ne supprimera pas les compteurs de couverture
pour le corps de fonction inutilisé. Par conséquent, lorsqu'elles sont instrumentées, toutes les utilisations de cette fonction sauf une
affichera zéro compte.

Si la fonction est alignée à plusieurs endroits, la structure de bloc à chaque endroit peut
pas être le même. Par exemple, une condition peut maintenant être calculable au moment de la compilation dans
certains cas. Parce que la couverture de toutes les utilisations de la fonction en ligne sera affichée
pour les mêmes lignes source, les décomptes de lignes eux-mêmes peuvent sembler incohérents.

Les applications de longue durée peuvent utiliser les fonctionnalités "_gcov_reset" et "_gcov_dump" pour
restreindre la collecte de profils à la région de programme d'intérêt. Appeler "_gcov_reset(void)"
effacera tous les compteurs de profil à zéro, et l'appel de "_gcov_dump(void)" provoquera le
informations de profil collectées à ce stade pour être transférées à .gcda fichiers de sortie.

Utilisez aarch64-linux-gnu-gcov en ligne en utilisant les services onworks.net