Ad

favicon do OnWorks
InglêsFrancêsAlemãoItalianoPortuguêsRussaEspanhol

mips-linux-gnu-gcov - Online na nuvem

Execute mips-linux-gnu-gcov no provedor de hospedagem gratuita OnWorks no Ubuntu Online, Fedora Online, emulador online do Windows ou emulador online do MAC OS

Este é o comando mips-linux-gnu-gcov que pode ser executado no provedor de hospedagem gratuita OnWorks usando uma de nossas várias estações de trabalho online gratuitas, como Ubuntu Online, Fedora Online, emulador online Windows ou emulador online MAC OS

PROGRAMA:

NOME


gcov - ferramenta de teste de cobertura

SINOPSE


gcov [-v|--versão] [-h|--Socorro]
[-a|--todos os blocos]
[-b|--probabilidades de ramificação]
[-c|--contagem de filiais]
[-d|--display-progresso]
[-f|- resumos de funções]
[-i|--formato intermediário]
[-l|--nomes de arquivos longos]
[-m|--deangled-names]
[-n|- sem saída]
[-o|--diretório-objeto diretório | arquivo]
[-p|--preserve-path]
[-r|--somente relativo]
[-s|--source-prefix anuário]
[-u|--unconditional-branchs]
arquivos

DESCRIÇÃO


gcov é um programa de cobertura de teste. Use-o em conjunto com o GCC para analisar seus programas para
ajudam a criar um código de execução mais rápido e eficiente e a descobrir partes não testadas de seu
programa. Você pode usar gcov como uma ferramenta de criação de perfil para ajudar a descobrir onde sua otimização
esforços afetarão melhor o seu código. Você também pode usar gcov junto com o outro perfil
ferramenta, gprof, para avaliar quais partes do seu código usam a maior quantidade de tempo de computação.

As ferramentas de criação de perfil ajudam a analisar o desempenho do seu código. Usando um profiler como gcov
or gprof, você pode descobrir algumas estatísticas básicas de desempenho, como:

* com que frequência cada linha de código é executada

* quais linhas de código são realmente executadas

* quanto tempo de computação cada seção do código usa

Depois de saber essas coisas sobre como seu código funciona quando compilado, você pode olhar para cada
módulo para ver quais módulos devem ser otimizados. gcov ajuda você a determinar onde trabalhar
na otimização.

Os desenvolvedores de software também usam o teste de cobertura em conjunto com os conjuntos de teste, para garantir
o software é realmente bom o suficiente para um lançamento. Os conjuntos de teste podem verificar se um programa
funciona conforme o esperado; um programa de cobertura testa para ver quanto do programa é exercido por
a suíte de teste. Os desenvolvedores podem então determinar quais tipos de casos de teste precisam ser adicionados
os conjuntos de teste para criar melhores testes e um melhor produto final.

Você deve compilar seu código sem otimização se planeja usar gcov porque o
otimização, combinando algumas linhas de código em uma função, pode não fornecer tanto
informações conforme você precisa para procurar por "pontos de acesso", onde o código está usando uma grande quantidade de
hora do computador. Da mesma forma, porque gcov acumula estatísticas por linha (pelo menos
resolução), funciona melhor com um estilo de programação que coloca apenas uma instrução em cada
linha. Se você usar macros complicadas que se expandem para loops ou outras estruturas de controle,
as estatísticas são menos úteis --- elas relatam apenas na linha onde a macro chama
parece. Se suas macros complexas se comportam como funções, você pode substituí-las por inline
funções para resolver este problema.

gcov cria um arquivo de log chamado sourcefile.gcov que indica quantas vezes cada linha de
um arquivo fonte sourcefile.c foi executado. Você pode usar esses arquivos de log junto com gprof para
ajuda no ajuste fino do desempenho de seus programas. gprof dá informações de tempo para você
pode usar junto com as informações que você obtém de gcov.

gcov funciona apenas em código compilado com GCC. Não é compatível com nenhum outro perfil
ou mecanismo de cobertura de teste.

OPÇÕES


-h
--Socorro
Exibir ajuda sobre como usar gcov (na saída padrão) e saia sem fazer qualquer
processamento adicional.

-v
--versão
Exibem o gcov número da versão (na saída padrão) e saia sem fazer nenhum
processamento adicional.

-a
--todos os blocos
Escreva contagens de execução individuais para cada bloco básico. Normalmente saídas gcov
a execução conta apenas para os blocos principais de uma linha. Com esta opção você pode
determinar se os blocos dentro de uma única linha não estão sendo executados.

-b
--probabilidades de ramificação
Grave frequências de ramificação no arquivo de saída e grave informações de resumo de ramificação para o
saída padrão. Esta opção permite que você veja com que freqüência cada branch em seu programa
foi pego. Ramificações incondicionais não serão mostradas, a menos que o -u opção é fornecida.

-c
--contagem de filiais
Escreva as frequências de ramal como o número de ramais tomados, em vez da porcentagem
de ramos tomados.

-n
- sem saída
Não crie o gcov arquivo de saída.

-l
--nomes de arquivos longos
Crie nomes de arquivo longos para os arquivos de origem incluídos. Por exemplo, se o arquivo de cabeçalho xh
contém código e foi incluído no arquivo ac, então correndo gcov no arquivo ac
irá produzir um arquivo de saída chamado ac ## xhgcov em vez de xhgcov. Isso pode ser
útil se xh está incluído em vários arquivos de origem e você deseja ver o indivíduo
contribuições. Se você usar o -p opção, os nomes de arquivo incluídos e incluídos
serão nomes de caminho completos.

-p
--preserve-path
Preserve as informações completas do caminho nos nomes dos .gcov arquivos. Sem
esta opção, apenas o componente do nome do arquivo é usado. Com esta opção, todos os diretórios
são usados, com / caracteres traduzidos para # personagens, . componentes do diretório removidos
e irremovível .. componentes renomeados para ^. Isso é útil se os arquivos de origem estiverem em
vários diretórios diferentes.

-r
--somente relativo
Produz apenas informações sobre os arquivos fonte com um nome de caminho relativo (após a fonte
elisão do prefixo). Caminhos absolutos são geralmente arquivos de cabeçalho do sistema e cobertura de qualquer
funções embutidas nele normalmente são desinteressantes.

-f
- resumos de funções
Resumos de saída para cada função, além do resumo em nível de arquivo.

-o diretório | arquivo
--diretório-objeto anuário
--arquivo-objeto filete
Especifique o diretório que contém os arquivos de dados gcov ou o nome do caminho do objeto.
O .gcnoe .gcda os arquivos de dados são pesquisados ​​usando esta opção. Se um diretório é
especificado, os arquivos de dados estão nesse diretório e nomeados após o nome do arquivo de entrada,
sem sua extensão. Se um arquivo for especificado aqui, os arquivos de dados serão nomeados após
esse arquivo, sem sua extensão.

-s anuário
--source-prefix anuário
Um prefixo para nomes de arquivos de origem a serem removidos ao gerar os arquivos de cobertura de saída.
Esta opção é útil ao construir em um diretório separado, e o nome do caminho para o
o diretório de origem não é desejado ao determinar os nomes dos arquivos de saída. Observe que este
a detecção de prefixo é aplicada antes de determinar se o arquivo de origem é absoluto.

-u
--unconditional-branchs
Quando as probabilidades de ramificação são fornecidas, inclua aquelas de ramificações incondicionais.
Ramificações incondicionais normalmente não são interessantes.

-d
--display-progresso
Exibe o progresso na saída padrão.

-i
--formato intermediário
Arquivo gcov de saída em um formato de texto intermediário fácil de analisar que pode ser usado por lcov
ou outras ferramentas. A saída é um único .gcov arquivo por .gcda Arquivo. Nenhum código-fonte é
necessário.

O formato do intermediário .gcov o arquivo é um texto simples com uma entrada por linha

Arquivo:
função: , ,
lcount: ,
filial: ,

Onde o é
notexec (Branch não executado)
tomada (filial executada e tomada)
nottaken (ramo executado, mas não levado)

Pode haver vários entradas em um gcov intermediário
Arquivo. Todas as entradas seguindo um pertencem a esse arquivo de origem
até a próxima entrada.

Aqui está um exemplo de quando -i é usado em conjunto com -b opção:

arquivo: array.cc
função: 11,1, _Z3sumRKSt6vectorIPiSaIS0_EE
função: 22,1, principal
lcount: 11,1
lcount: 12,1
lcount: 14,1
ramo: 14, tomado
lcount: 26,1
branch: 28, não tomada

-m
--deangled-names
Exibe nomes de função demangled na saída. O padrão é mostrar a função mutilada
nomes.

gcov deve ser executado com o diretório atual igual ao de quando você invocou o
compilador. Caso contrário, não será possível localizar os arquivos de origem. gcov produz arquivos
chamado Mangledname.gcov no diretório atual. Estes contêm as informações de cobertura
do arquivo de origem ao qual eles correspondem. XNUMX .gcov arquivo é produzido para cada fonte (ou
header) contendo código, que foi compilado para produzir os arquivos de dados. o
nome mutilado parte do nome do arquivo de saída geralmente é simplesmente o nome do arquivo de origem, mas pode
ser algo mais complicado se o -l or -p opções são fornecidas. Consulte essas opções
para obter detalhes.

Se você invocar gcov com vários arquivos de entrada, as contribuições de cada arquivo de entrada são
somados. Normalmente, você o invocaria com a mesma lista de arquivos do link final de
seu executável.

O .gcov arquivos contêm o : campos separados junto com o código-fonte do programa. O formato
is

: :

Informações de bloco adicionais podem suceder a cada linha, quando solicitadas por opção de linha de comando.
O execução_conta is - para linhas que não contêm código. Linhas não executadas são marcadas #####
or ====, dependendo se são alcançáveis ​​por caminhos não excepcionais ou apenas
caminhos excepcionais, como manipuladores de exceção C ++, respectivamente.

Algumas linhas de informação no início têm número da linha de zero. Estas linhas de preâmbulo são
do formulário

-: 0: :

A ordem e o número dessas linhas do preâmbulo serão aumentados como gcov desenvolvimento
progride --- não confie que eles permaneçam inalterados. Usar etiqueta para localizar um particular
linha do preâmbulo.

As informações adicionais do bloco estão no formato



O informação é legível por humanos, mas projetado para ser simples o suficiente para análise de máquina
demasiado.

Ao imprimir percentagens, 0% e 100% são impressos apenas quando os valores são exatamente 0% e
100% respectivamente. Outros valores que convencionalmente seriam arredondados para 0% ou 100% são
em vez disso, é impresso como o valor não-limite mais próximo.

Ao usar gcov, você deve primeiro compilar seu programa com duas opções especiais do GCC:
-fprofile-arcs -teste-cobertura. Isso diz ao compilador para gerar
informações necessárias para gcov (basicamente um gráfico de fluxo do programa) e também inclui
código adicional nos arquivos de objeto para gerar as informações de perfil extras necessárias
por gcov. Esses arquivos adicionais são colocados no diretório onde o arquivo objeto está
localizado.

A execução do programa fará com que a saída do perfil seja gerada. Para cada arquivo de origem
compilado com -fprofile-arcs, um acompanhante .gcda o arquivo será colocado no arquivo objeto
diretório.

Corrida gcov com os nomes dos arquivos-fonte do seu programa como argumentos irão agora produzir uma lista
do código junto com a frequência de execução de cada linha. Por exemplo, se o seu programa
é chamado tmp.c, isso é o que você vê quando usa o básico gcov instalação:

$ gcc -fprofile-arcs -ftest-cobertura tmp.c
$ a.out
$ gcov tmp.c
90.00% de 10 linhas de origem executadas no arquivo tmp.c
Criando tmp.c.gcov.

O arquivo tmp.c.gcov contém saída de gcov. Aqui está uma amostra:

-: 0: Fonte: tmp.c
-: 0: Gráfico: tmp.gcno
-: 0: Dados: tmp.gcda
-: 0: Executa: 1
-: 0: Programas: 1
-: 1: #include
-: 2:
-: 3: int main (vazio)
1: 4: {
1: 5: int i, total;
-: 6:
1: 7: total = 0;
-: 8:
11: 9: para (i = 0; i <10; i ++)
10: 10: total + = i;
-: 11:
1: 12: if (total! = 45)
#####: 13: printf ("Falha \ n");
-: 14: mais
1:15: printf ("Sucesso \ n");
1:16: retorno 0;
-: 17:}

Quando você usa o -a opção, você obterá contagens de blocos individuais, e a saída parece
como isso:

-: 0: Fonte: tmp.c
-: 0: Gráfico: tmp.gcno
-: 0: Dados: tmp.gcda
-: 0: Executa: 1
-: 0: Programas: 1
-: 1: #include
-: 2:
-: 3: int main (vazio)
1: 4: {
1: 4-bloco 0
1: 5: int i, total;
-: 6:
1: 7: total = 0;
-: 8:
11: 9: para (i = 0; i <10; i ++)
11: 9-bloco 0
10: 10: total + = i;
10: 10-bloco 0
-: 11:
1: 12: if (total! = 45)
1: 12-bloco 0
#####: 13: printf ("Falha \ n");
$$$$$: 13 blocos 0
-: 14: mais
1:15: printf ("Sucesso \ n");
1: 15-bloco 0
1:16: retorno 0;
1: 16-bloco 0
-: 17:}

Neste modo, cada bloco básico é mostrado apenas em uma linha - a última linha do bloco. UMA
bloco multilinha só contribuirá para a contagem de execução dessa última linha, e outros
as linhas não serão mostradas para conter o código, a menos que os blocos anteriores terminem nessas linhas. o
a contagem total de execução de uma linha é mostrada e as linhas subsequentes mostram as contagens de execução
para blocos individuais que terminam nessa linha. Após cada bloqueio, o ramal e as contagens de chamadas
do bloco será mostrado, se o -b opção é fornecida.

Por causa da forma como os instrumentos do GCC chamam, uma contagem de chamadas pode ser mostrada após uma linha sem
blocos individuais. Como você pode ver, a linha 13 contém um bloco básico que não foi executado.

Quando você usa o -b opção, sua saída é semelhante a esta:

$ gcov -b tmp.c
90.00% de 10 linhas de origem executadas no arquivo tmp.c
80.00% de 5 ramos executados no arquivo tmp.c
80.00% de 5 ramos obtidos pelo menos uma vez no arquivo tmp.c
50.00% de 2 chamadas executadas no arquivo tmp.c
Criando tmp.c.gcov.

Aqui está uma amostra de um resultado tmp.c.gcov arquivo:

-: 0: Fonte: tmp.c
-: 0: Gráfico: tmp.gcno
-: 0: Dados: tmp.gcda
-: 0: Executa: 1
-: 0: Programas: 1
-: 1: #include
-: 2:
-: 3: int main (vazio)
função principal chamada 1 retornou 1 bloco executado 75%
1: 4: {
1: 5: int i, total;
-: 6:
1: 7: total = 0;
-: 8:
11: 9: para (i = 0; i <10; i ++)
ramo 0 obtido 91% (queda)
filial 1 tomada 9%
10: 10: total + = i;
-: 11:
1: 12: if (total! = 45)
ramo 0 obtido 0% (queda)
filial 1 tomada 100%
#####: 13: printf ("Falha \ n");
chamada 0 nunca executada
-: 14: mais
1:15: printf ("Sucesso \ n");
a chamada 0 chamada 1 retornou 100%
1:16: retorno 0;
-: 17:}

Para cada função, uma linha é impressa mostrando quantas vezes a função é chamada, como
muitas vezes ele retorna e qual porcentagem dos blocos da função foram executados.

Para cada bloco básico, uma linha é impressa após a última linha do bloco básico descrevendo
o ramal ou chamada que finaliza o bloqueio básico. Pode haver várias filiais e chamadas
listado para uma única linha de origem se houver vários blocos básicos que terminam nessa linha.
Nesse caso, as filiais e as chamadas recebem um número. Não existe uma maneira simples de
mapeie essas ramificações e as chamadas de volta às construções de origem. Em geral, porém, o mais baixo
ramal ou chamada numerada corresponderá à construção mais à esquerda na linha de origem.

Para uma ramificação, se ela foi executada pelo menos uma vez, uma porcentagem indica o número de
vezes que o ramo foi tomado dividido pelo número de vezes que o ramo foi executado será
impresso. Caso contrário, a mensagem "nunca executado" é impressa.

Para uma chamada, se ela foi executada pelo menos uma vez, uma porcentagem indicando o número de
vezes que a chamada retornada dividido pelo número de vezes que a chamada foi executada será
impresso. Isso geralmente será 100%, mas pode ser menor para funções que chamam "sair" ou
"longjmp" e, portanto, pode não retornar sempre que for chamado.

As contagens de execução são cumulativas. Se o programa de exemplo foi executado novamente sem
removendo o .gcda arquivo, a contagem do número de vezes que cada linha na fonte foi
executado seria adicionado aos resultados da (s) execução (ões) anterior (es). Isso é potencialmente útil
em várias formas. Por exemplo, pode ser usado para acumular dados ao longo de uma série de
programa é executado como parte de um conjunto de verificação de teste ou para fornecer mais precisão a longo prazo
informações sobre um grande número de execuções do programa.

Os dados na .gcda os arquivos são salvos imediatamente antes de o programa ser encerrado. Para cada
arquivo fonte compilado com -fprofile-arcs, o código de criação de perfil primeiro tenta ler em um
existente .gcda Arquivo; se o arquivo não corresponder ao executável (número diferente de
contagem de blocos) ele irá ignorar o conteúdo do arquivo. Em seguida, adiciona a nova execução
conta e finalmente grava os dados no arquivo.

utilização gcov com GCC Otimização

Se você planeja usar gcov para ajudar a otimizar seu código, você deve primeiro compilar seu programa
com duas opções especiais do GCC: -fprofile-arcs -teste-cobertura. Além disso, você pode
usar qualquer outra opção do GCC; mas se você quiser provar que cada linha em seu programa
foi executado, você não deve compilar com otimização ao mesmo tempo. Em algumas máquinas
o otimizador pode eliminar algumas linhas de código simples combinando-as com outras linhas.
Por exemplo, código como este:

if (a! = b)
c é 1;
outro
c é 0;

pode ser compilado em uma instrução em algumas máquinas. Neste caso, não há como
gcov para calcular contagens de execução separadas para cada linha porque não há
código para cada linha. Daí o gcov a saída fica assim se você compilou o programa
com otimização:

100: 12: if (a! = B)
100: 13: c = 1;
100: 14: else
100: 15: c = 0;

A saída mostra que este bloco de código, combinado pela otimização, foi executado 100 vezes.
Em certo sentido, este resultado está correto, porque havia apenas uma instrução representando
todas as quatro dessas linhas. No entanto, a saída não indica quantas vezes o resultado
foi 0 e quantas vezes o resultado foi 1.

Funções embutidas podem criar contagens de linha inesperadas. As contagens de linha são mostradas para o
código-fonte da função embutida, mas o que é mostrado depende de onde a função está
inline, ou se não estiver inline.

Se a função não estiver embutida, o compilador deve emitir uma cópia fora de linha do
função, em qualquer arquivo de objeto que precise dela. Se arquivoA.o e arquivoB.o ambos contêm fora de
corpos de linha de uma função inlinável específica, eles também conterão cobertura
conta para essa função. Quando arquivoA.o e arquivoB.o estão ligados entre si, o vinculador irá,
em muitos sistemas, selecione um dos corpos fora de linha para todas as chamadas para essa função,
e remover ou ignorar o outro. Infelizmente, isso não removerá os contadores de cobertura
para o corpo de função não utilizado. Portanto, quando instrumentado, todos, exceto um uso dessa função
mostrará contagens zero.

Se a função estiver embutida em vários lugares, a estrutura do bloco em cada local pode
não ser o mesmo. Por exemplo, uma condição agora pode ser calculada em tempo de compilação em
alguns casos. Porque a cobertura de todos os usos da função inline será mostrada
para as mesmas linhas de origem, as próprias contagens de linha podem parecer inconsistentes.

Aplicativos de longa duração podem usar os recursos "_gcov_reset" e "_gcov_dump" para
restringir a coleta de perfis à região do programa de interesse. Chamando "_gcov_reset (void)"
irá limpar todos os contadores de perfil para zero, e chamar "_gcov_dump (void)" fará com que o
informações de perfil coletadas naquele ponto para serem despejadas em .gcda arquivos de saída.

Use mips-linux-gnu-gcov online usando serviços onworks.net


Ad


Ad

Programas online Linux e Windows mais recentes: