C Language
Valgrind

Sintaxis

• valgrind nombre-programa- argumentos-opcionales < entrada de prueba

Observaciones

Corriendo valgrind

valgrind ./my-program arg1 arg2 < test-input

Esto ejecutará su programa y producirá un informe de las asignaciones y desasignaciones que realizó. También le advertirá acerca de los errores comunes, como el uso de memoria no inicializada, la desreferenciación de los punteros a lugares extraños, la eliminación del final de los bloques asignados con malloc o la ausencia de bloques libres.

Añadiendo banderas

También puede activar más pruebas, como:

valgrind -q --tool=memcheck --leak-check=yes ./my-program arg1 arg2 < test-input

Consulte valgrind --help para obtener más información sobre las (muchas) opciones, o consulte la documentación en http://valgrind.org/ para obtener información detallada sobre el significado de la salida.

Bytes perdidos - Olvidando liberar

Aquí hay un programa que llama malloc pero no es gratis:

#include <stdio.h>
#include <stdlib.h>

int main(int argc, char **argv)
{
    char *s;

    s = malloc(26); // the culprint 

    return 0;
}

Sin argumentos adicionales, valgrind no buscará este error.

Pero si --leak-check=yes o --tool=memcheck , se quejará y mostrará las líneas responsables de esas pérdidas de memoria si el programa se compiló en modo de depuración:

$ valgrind -q --leak-check=yes ./missing_free
==4776== 26 bytes in 1 blocks are definitely lost in loss record 1 of 1
==4776==    at 0x4024F20: malloc (vg_replace_malloc.c:236)
==4776==    by 0x80483F8: main (missing_free.c:9)
==4776== 

Si el programa no está compilado en modo de depuración (por ejemplo, con el indicador -g en GCC), todavía nos mostrará dónde ocurrió la fuga en términos de la función relevante, pero no las líneas.

Esto nos permite retroceder y ver qué bloque se asignó en esa línea e intentar rastrear hacia adelante para ver por qué no se liberó.

Errores más comunes encontrados al usar Valgrind

Valgrind le proporciona las líneas en las que se produjo el error al final de cada línea en el formato (file.c:line_no) . Los errores en valgrind se resumen de la siguiente manera:

ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0)

Los errores más comunes incluyen:

1. Errores ilegales de lectura / escritura

==8451== Invalid read of size 2
==8451==    at 0x4E7381D: getenv (getenv.c:84)
==8451==    by 0x4EB1559: __libc_message (libc_fatal.c:80)
==8451==    by 0x4F5256B: __fortify_fail (fortify_fail.c:37)
==8451==    by 0x4F5250F: __stack_chk_fail (stack_chk_fail.c:28)
==8451==    by 0x40059C: main (valg.c:10)
==8451==  Address 0x700000007 is not stack'd, malloc'd or (recently) free'd

Esto sucede cuando el código comienza a acceder a la memoria que no pertenece al programa. El tamaño de la memoria a la que se accede también le da una indicación de qué variable se usó.

2. Uso de variables no inicializadas

==8795== 1 errors in context 5 of 8:
==8795== Conditional jump or move depends on uninitialised value(s)
==8795==    at 0x4E881AF: vfprintf (vfprintf.c:1631)
==8795==    by 0x4E8F898: printf (printf.c:33)
==8795==    by 0x400548: main (valg.c:7)

De acuerdo con el error, en la línea 7 de main de valg.c , la llamada a printf() pasó una variable sin inicializar a printf .

3. Liberación ilegal de la memoria.

==8954== Invalid free() / delete / delete[] / realloc()
==8954==    at 0x4C2EDEB: free (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so)
==8954==    by 0x4005A8: main (valg.c:10)
==8954==  Address 0x5203040 is 0 bytes inside a block of size 240 free'd
==8954==    at 0x4C2EDEB: free (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so)
==8954==    by 0x40059C: main (valg.c:9)
==8954==  Block was alloc'd at
==8954==    at 0x4C2DB8F: malloc (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so)
==8954==    by 0x40058C: main (valg.c:7)

Según valgrind, el código liberó la memoria ilegalmente (una segunda vez) en la línea 10 de valg.c , mientras que ya estaba liberado en la línea 9 , y al bloque mismo se le asignó memoria en la línea 7 .