InglésFrancésAlemánItalianoPortuguésrusoEspañol

icono de página de OnWorks

mips64el-linux-gnuabi64-gcov-5 - Online en la nube

Ejecute mips64el-linux-gnuabi64-gcov-5 en el proveedor de alojamiento gratuito de OnWorks sobre Ubuntu Online, Fedora Online, emulador en línea de Windows o emulador en línea de MAC OS

Este es el comando mips64el-linux-gnuabi64-gcov-5 que se puede ejecutar en el proveedor de alojamiento gratuito de OnWorks utilizando una de nuestras múltiples estaciones de trabajo en línea gratuitas como Ubuntu Online, Fedora Online, emulador en línea de Windows o emulador en línea de MAC OS.

PROGRAMA:

NOMBRE


gcov - herramienta de prueba de cobertura

SINOPSIS


gcov [-v|--versión] [-h|--ayuda]
[-a|--todos los bloques]
[-b|--probabilidades de rama]
[-c|- recuentos de ramas]
[-d|--display-progreso]
[-f|- resúmenes de funciones]
[-i|--formato intermedio]
[-l|--nombres-de-archivos-largos]
[-m|--nombres-desgarrados]
[-n|--ninguna salida]
[-o|- directorio de objetos directorio | archivo]
[-p|--preservar-caminos]
[-r|- solo relativo]
[-s|--fuente-prefijo directorio]
[-u|- ramas-incondicionales]
archivos

DESCRIPCIÓN


gcov es un programa de cobertura de prueba. Úselo en conjunto con GCC para analizar sus programas para
ayudar a crear un código de ejecución más eficiente y más rápido y descubrir partes no probadas de su
programa. Puedes usar gcov como herramienta de creación de perfiles para ayudar a descubrir dónde está su optimización
los esfuerzos afectarán mejor a su código. También puedes usar gcov junto con el otro perfil
herramienta, gprof, para evaluar qué partes de su código utilizan la mayor cantidad de tiempo de cálculo.

Las herramientas de creación de perfiles lo ayudan a analizar el rendimiento de su código. Usando un generador de perfiles como gcov
or gprof, puede encontrar algunas estadísticas básicas de rendimiento, como:

* con qué frecuencia se ejecuta cada línea de código

* qué líneas de código se ejecutan realmente

* cuánto tiempo de computación usa cada sección de código

Una vez que sepa estas cosas sobre cómo funciona su código cuando se compila, puede mirar cada
módulo para ver qué módulos deben optimizarse. gcov te ayuda a determinar dónde trabajar
en optimización.

Los desarrolladores de software también utilizan las pruebas de cobertura junto con las suites de prueba, para asegurarse
el software es lo suficientemente bueno para un lanzamiento. Testsuites puede verificar que un programa
funciona como se esperaba; un programa de cobertura prueba para ver cuánto del programa es ejercido por
la suite de pruebas. Luego, los desarrolladores pueden determinar qué tipos de casos de prueba deben agregarse a
los conjuntos de pruebas para crear mejores pruebas y un mejor producto final.

Debe compilar su código sin optimización si planea usar gcov porque el
La optimización, al combinar algunas líneas de código en una función, puede no brindarle tanto
información, ya que necesita buscar "puntos calientes" donde el código utiliza una gran cantidad de
tiempo de la computadora. Asimismo, porque gcov acumula estadísticas por línea (en el nivel más bajo
resolución), funciona mejor con un estilo de programación que coloca solo una declaración en cada
línea. Si usa macros complicadas que se expanden a bucles u otras estructuras de control,
las estadísticas son menos útiles --- solo informan en la línea donde la llamada macro
aparece. Si sus macros complejas se comportan como funciones, puede reemplazarlas con inline
funciones para resolver este problema.

gcov crea un archivo de registro llamado sourcefile.gcov que indica cuántas veces cada línea de
un archivo fuente archivofuente.c ha ejecutado. Puede utilizar estos archivos de registro junto con gprof a
ayuda a afinar el rendimiento de sus programas. gprof le da información de tiempo
puede utilizar junto con la información que obtiene de gcov.

gcov funciona solo en código compilado con GCC. No es compatible con ningún otro perfil.
o mecanismo de cobertura de prueba.

OPCIONES


-h
--ayuda
Mostrar ayuda sobre el uso gcov (en la salida estándar) y salir sin hacer nada
más procesamiento.

-v
--versión
Mostrar el gcov número de versión (en la salida estándar) y salir sin hacer ningún
más procesamiento.

-a
--todos los bloques
Escriba recuentos de ejecución individuales para cada bloque básico. Normalmente salidas gcov
la ejecución cuenta solo para los bloques principales de una línea. Con esta opción puedes
determinar si los bloques dentro de una sola línea no se están ejecutando.

-b
--probabilidades de rama
Escriba las frecuencias de las ramas en el archivo de salida y escriba la información de resumen de las ramas en el
salida estándar. Esta opción le permite ver con qué frecuencia cada rama de su programa
fue tomada. Las ramas incondicionales no se mostrarán, a menos que el -u se da la opción.

-c
- recuentos de ramas
Escriba las frecuencias de las sucursales como el número de sucursales tomadas, en lugar del porcentaje
de ramas tomadas.

-n
--ninguna salida
No cree el gcov archivo de salida.

-l
--nombres-de-archivos-largos
Cree nombres de archivo largos para los archivos de origen incluidos. Por ejemplo, si el archivo de encabezado xh
contiene código y se incluyó en el archivo C.A, luego corriendo gcov en el archivo C.A
producirá un archivo de salida llamado ac ## xhgcov en lugar de xhgcov. Esto puede ser
útil si xh está incluido en varios archivos de origen y desea ver el individuo
contribuciones. Si usa el -p opción, tanto el nombre de archivo incluido como el incluido
serán nombres de ruta completos.

-p
--preservar-caminos
Conservar la información de ruta completa en los nombres de los generados .gcov archivos. Sin
esta opción, solo se utiliza el componente de nombre de archivo. Con esta opción, todos los directorios
se utilizan, con / caracteres traducidos a # caracteres, . componentes de directorio eliminados
e inamovible .. componentes renombrados a ^. Esto es útil si los archivos fuente están en
varios directorios diferentes.

-r
- solo relativo
Solo genera información sobre archivos de origen con un nombre de ruta relativo (después del código fuente).
prefijo elisión). Las rutas absolutas suelen ser archivos de encabezado del sistema y la cobertura de cualquier
las funciones en línea en el mismo normalmente no son interesantes.

-f
- resúmenes de funciones
Resúmenes de salida para cada función además del resumen a nivel de archivo.

-o directorio | archivo
- directorio de objetos directorio
--archivo de objeto presentar
Especifique el directorio que contiene los archivos de datos gcov o el nombre de la ruta del objeto.
El .gcnoy .gcda Se buscan archivos de datos para usar esta opción. Si un directorio es
especificado, los archivos de datos están en ese directorio y reciben el nombre del archivo de entrada,
sin su extensión. Si se especifica un archivo aquí, los archivos de datos reciben el nombre de
ese archivo, sin su extensión.

-s directorio
--fuente-prefijo directorio
Un prefijo para los nombres de los archivos de origen que se eliminarán al generar los archivos de cobertura de salida.
Esta opción es útil cuando se crea en un directorio separado, y el nombre de la ruta al
El directorio de origen no se desea al determinar los nombres de los archivos de salida. Tenga en cuenta que esto
La detección de prefijo se aplica antes de determinar si el archivo de origen es absoluto.

-u
- ramas-incondicionales
Cuando se den las probabilidades de las ramas, incluya las de las ramas incondicionales.
Las ramas incondicionales normalmente no son interesantes.

-d
--display-progreso
Muestra el progreso en la salida estándar.

-i
--formato intermedio
Genere el archivo gcov en un formato de texto intermedio fácil de analizar que puede ser utilizado por lcov
u otras herramientas. La salida es un solo .gcov archivo por .gcda expediente. Ningún código fuente es
requerida.

El formato del intermedio .gcov el archivo es texto sin formato con una entrada por línea

expediente:
función: , ,
recuento: ,
rama: ,

Donde el es
notexec (rama no ejecutada)
tomado (Rama ejecutada y tomada)
nottaken (rama ejecutada, pero no tomada)

Puede haber varios entradas en un gcov intermedio
expediente. Todas las entradas que siguen a pertenecen a ese archivo fuente
hasta el siguiente entrada.

Aquí hay una muestra cuando -i se usa junto con -b opción:

archivo: array.cc
función: 11,1, _Z3sumRKSt6vectorIPiSaIS0_EE
función: 22,1, principal
recuento: 11,1
recuento: 12,1
recuento: 14,1
rama: 14, tomada
recuento: 26,1
rama: 28, no tomada

-m
--nombres-desgarrados
Muestra los nombres de las funciones exigidas en la salida. El valor predeterminado es mostrar la función destrozada
Nombres

gcov debe ejecutarse con el directorio actual igual que cuando invocó el
compilador. De lo contrario, no podrá localizar los archivos de origen. gcov produce archivos
llamado nombremangled.gcov en el directorio actual. Estos contienen la información de cobertura
del archivo fuente al que corresponden. Uno .gcov se produce un archivo para cada fuente (o
header) que contiene el código, que fue compilado para producir los archivos de datos. los
nombre destrozado parte del nombre del archivo de salida suele ser simplemente el nombre del archivo de origen, pero puede
Sería algo más complicado si el -l or -p se dan opciones. Consulte esas opciones
para más detalles.

Si invocas gcov con varios archivos de entrada, las contribuciones de cada archivo de entrada son
resumido. Normalmente, lo invocaría con la misma lista de archivos que el enlace final de
su ejecutable.

El .gcov los archivos contienen el : campos separados junto con el código fuente del programa. El formato
is

: :

La información de bloque adicional puede tener éxito en cada línea, cuando se solicita mediante la opción de línea de comando.
El cuenta_de_ejecución is - para líneas que no contienen código. Las líneas no ejecutadas están marcadas #####
or ====, dependiendo de si son accesibles por caminos no excepcionales o solo
rutas excepcionales como los controladores de excepciones de C ++, respectivamente.

Algunas líneas de información al principio tienen número de línea de cero. Estas líneas de preámbulo son
de la forma

-: 0: :

El orden y el número de estas líneas de preámbulo se incrementará como gcov Desarrollo de Productos
progresa --- no confíe en que permanezcan sin cambios. Usar etiqueta para localizar un particular
línea de preámbulo.

La información adicional del bloque tiene la forma



El información es legible por humanos, pero está diseñado para ser lo suficientemente simple para el análisis automático


Al imprimir porcentajes, 0% y 100% solo se imprimen cuando los valores son exactamente 0% y
100% respectivamente. Otros valores que convencionalmente se redondearían al 0% o al 100% son
en su lugar, se imprime como el valor no límite más cercano.

Cuando usas gcov, primero debe compilar su programa con dos opciones especiales de GCC:
-fprofile-arcos -cobertura-de-prueba. Esto le dice al compilador que genere más
información que necesita gcov (básicamente un diagrama de flujo del programa) y también incluye
código adicional en los archivos de objeto para generar la información de perfil adicional necesaria
por gcov. Estos archivos adicionales se colocan en el directorio donde se encuentra el archivo de objeto.
situado.

La ejecución del programa hará que se genere una salida de perfil. Para cada archivo fuente
compilado con -fprofile-arcos, un acompañante .gcda el archivo se colocará en el archivo de objeto
directorio.

Running gcov con los nombres de los archivos fuente de su programa, ya que los argumentos ahora producirán una lista
del código junto con la frecuencia de ejecución de cada línea. Por ejemplo, si su programa
se llama tmp.c, esto es lo que ves cuando usas el básico gcov instalaciones:

$ gcc -fprofile-arcs -ftest-coberturas tmp.c
$ a.fuera
$ gcov tmp.c
90.00% de 10 líneas fuente ejecutadas en el archivo tmp.c
Creando tmp.c.gcov.

El archivo tmp.c.gcov contiene salida de gcov. Aquí hay una muestra:

-: 0: Fuente: tmp.c
-: 0: Gráfico: tmp.gcno
-: 0: Datos: tmp.gcda
-: 0: Ejecuciones: 1
-: 0: Programas: 1
-: 1: #incluir
-: 2:
-: 3: int main (vacío)
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: si (total! = 45)
#####: 13: printf ("Fallo \ n");
-: 14: más
1:15: printf ("Correcto \ n");
1:16: devuelve 0;
-: 17:}

Cuando se utiliza el -a opción, obtendrá recuentos de bloques individuales, y la salida se ve
Me gusta esto:

-: 0: Fuente: tmp.c
-: 0: Gráfico: tmp.gcno
-: 0: Datos: tmp.gcda
-: 0: Ejecuciones: 1
-: 0: Programas: 1
-: 1: #incluir
-: 2:
-: 3: int main (vacío)
1: 4: {
1: 4 bloques 0
1: 5: int i, total;
-: 6:
1: 7: total = 0;
-: 8:
11: 9: para (i = 0; i <10; i ++)
11: 9 bloques 0
10:10: total + = i;
10: 10 bloques 0
-: 11:
1:12: si (total! = 45)
1: 12 bloques 0
#####: 13: printf ("Fallo \ n");
$$$$$: 13-bloque 0
-: 14: más
1:15: printf ("Correcto \ n");
1: 15 bloques 0
1:16: devuelve 0;
1: 16 bloques 0
-: 17:}

En este modo, cada bloque básico solo se muestra en una línea: la última línea del bloque. A
El bloque de varias líneas solo contribuirá al recuento de ejecución de esa última línea, y otras
no se mostrará que las líneas contengan código, a menos que los bloques anteriores terminen en esas líneas. los
Se muestra el recuento total de ejecución de una línea y las líneas siguientes muestran los recuentos de ejecución.
para bloques individuales que terminan en esa línea. Después de cada bloque, la rama y la llamada cuentan
del bloque se mostrará, si el -b se da la opción.

Debido a la forma en que GCC instrumenta las llamadas, se puede mostrar un recuento de llamadas después de una línea sin
bloques individuales. Como puede ver, la línea 13 contiene un bloque básico que no se ejecutó.

Cuando se utiliza el -b opción, su salida se ve así:

$ gcov -b tmp.c
90.00% de 10 líneas fuente ejecutadas en el archivo tmp.c
80.00% de 5 ramas ejecutadas en archivo tmp.c
80.00% de 5 ramas tomadas al menos una vez en el archivo tmp.c
50.00% de 2 llamadas ejecutadas en archivo tmp.c
Creando tmp.c.gcov.

Aquí hay una muestra de un resultado tmp.c.gcov archivo:

-: 0: Fuente: tmp.c
-: 0: Gráfico: tmp.gcno
-: 0: Datos: tmp.gcda
-: 0: Ejecuciones: 1
-: 0: Programas: 1
-: 1: #incluir
-: 2:
-: 3: int main (vacío)
la función principal llamada 1 devolvió 1 bloques ejecutados 75%
1: 4: {
1: 5: int i, total;
-: 6:
1: 7: total = 0;
-: 8:
11: 9: para (i = 0; i <10; i ++)
rama 0 tomada 91% (caída)
rama 1 tomada 9%
10:10: total + = i;
-: 11:
1:12: si (total! = 45)
rama 0 tomada 0% (caída)
rama 1 tomada 100%
#####: 13: printf ("Fallo \ n");
llamada 0 nunca ejecutada
-: 14: más
1:15: printf ("Correcto \ n");
llamada 0 llamada 1 devuelto 100%
1:16: devuelve 0;
-: 17:}

Para cada función, se imprime una línea que muestra cuántas veces se llama a la función, cuánto
muchas veces regresa y qué porcentaje de los bloques de la función se ejecutaron.

Para cada bloque básico, se imprime una línea después de la última línea del bloque básico que describe
la rama o llamada que finaliza el bloque básico. Puede haber múltiples ramas y llamadas
enumerados para una sola línea de origen si hay varios bloques básicos que terminan en esa línea.
En este caso, las sucursales y las llamadas reciben un número cada una. No hay una forma sencilla de
mapee estas ramas y devuelva las llamadas a las construcciones de origen. En general, sin embargo, el más bajo
rama numerada o llamada corresponderá a la construcción más a la izquierda en la línea fuente.

Para una rama, si se ejecutó al menos una vez, entonces un porcentaje que indica el número de
veces que se tomó la rama dividido por el número de veces que se ejecutó la rama se
impreso. De lo contrario, se imprime el mensaje "nunca ejecutado".

Para una llamada, si se ejecutó al menos una vez, entonces un porcentaje que indica el número de
veces la llamada devuelta dividida por el número de veces que se ejecutó la llamada será
impreso. Por lo general, será el 100%, pero puede ser menor para las funciones que llaman "salir" o
"longjmp" y, por lo tanto, es posible que no regresen cada vez que se llamen.

Los recuentos de ejecuciones son acumulativos. Si el programa de ejemplo se ejecutara de nuevo sin
la eliminación de la .gcda archivo, el recuento de la cantidad de veces que cada línea en la fuente fue
ejecutado se agregaría a los resultados de las ejecuciones anteriores. Esto es potencialmente útil
de varias maneras. Por ejemplo, podría usarse para acumular datos sobre una serie de
El programa se ejecuta como parte de un conjunto de verificación de pruebas o para proporcionar información más precisa a largo plazo.
información sobre un gran número de ejecuciones de programas.

Los datos de la .gcda Los archivos se guardan inmediatamente antes de que salga el programa. Para cada
archivo fuente compilado con -fprofile-arcos, el código de creación de perfiles primero intenta leer en un
existente .gcda expediente; si el archivo no coincide con el ejecutable (diferente número de
recuentos de bloques) ignorará el contenido del archivo. Luego agrega la nueva ejecución
cuenta y finalmente escribe los datos en el archivo.

Usar gcov con GCC Optimización

Si planeas usar gcov para ayudar a optimizar su código, primero debe compilar su programa
con dos opciones especiales de GCC: -fprofile-arcos -cobertura-de-prueba. Aparte de eso, puedes
utilizar cualquier otra opción de GCC; pero si quiere demostrar que cada línea de su programa
se ejecutó, no debe compilar con optimización al mismo tiempo. En algunas maquinas
el optimizador puede eliminar algunas líneas de código simples combinándolas con otras líneas.
Por ejemplo, un código como este:

si (a! = b)
c = 1;
más
c = 0;

se puede compilar en una instrucción en algunas máquinas. En este caso, no hay forma de
gcov para calcular recuentos de ejecución separados para cada línea porque no hay separados
código para cada línea. Por lo tanto, la gcov la salida se ve así si compiló el programa
con optimización:

100: 12: si (a! = B)
100: 13: c = 1;
100: 14: más
100: 15: c = 0;

El resultado muestra que este bloque de código, combinado por optimización, se ejecutó 100 veces.
En cierto sentido, este resultado es correcto, porque solo había una instrucción que representaba
las cuatro de estas líneas. Sin embargo, la salida no indica cuántas veces el resultado
fue 0 y cuántas veces el resultado fue 1.

Las funciones insertables pueden crear recuentos de líneas inesperados. Los recuentos de líneas se muestran para
código fuente de la función insertable, pero lo que se muestra depende de dónde está la función
en línea, o si no está en línea en absoluto.

Si la función no está en línea, el compilador debe emitir una copia fuera de línea de la
función, en cualquier archivo objeto que lo necesite. Si archivoA.o y archivoB.o ambos contienen de
cuerpos de línea de una función inlineable particular, ambos también contendrán cobertura
cuenta para esa función. Cuando archivoA.o y archivoB.o están vinculados, el vinculador lo hará,
en muchos sistemas, seleccione uno de esos cuerpos fuera de línea para todas las llamadas a esa función,
y eliminar o ignorar el otro. Desafortunadamente, no eliminará los contadores de cobertura.
para el cuerpo de función no utilizado. Por lo tanto, cuando se instrumenta, todos menos uno de los usos de esa función
mostrará cero recuentos.

Si la función está insertada en varios lugares, la estructura de bloques en cada ubicación podría
no ser el mismo. Por ejemplo, una condición ahora podría calcularse en tiempo de compilación en
algunos casos. Porque se mostrará la cobertura de todos los usos de la función en línea
para las mismas líneas de origen, los recuentos de líneas en sí pueden parecer inconsistentes.

Las aplicaciones de larga duración pueden utilizar las funciones "_gcov_reset" y "_gcov_dump" para
restringir la recopilación de perfiles a la región del programa de interés. Llamando a "_gcov_reset (void)"
borrará todos los contadores de perfil a cero, y llamar a "_gcov_dump (void)" hará que
información de perfil recopilada en ese punto para ser volcada a .gcda archivos de salida.

Use mips64el-linux-gnuabi64-gcov-5 en línea usando los servicios de onworks.net


Ad


Ad

Últimos programas en línea de Linux y Windows