Valgrind won't detect obvious errors

Question

I am in the process of learning C from Zed Shaw's excellent Learn C the Hard Way.

I am running Debian Sid with kernel version 3.9.0-vanillaice amd64 (I compiled it) with glibc 2.17 (installed from Debian's repo's).

I am on Exercise 4 in the book.

Here is my code:

#include <stdio.h>

//This program is purposefully messed up.

int main()
{
        int age = 10;
        int height;

        printf("I am %d years old.\n");
        printf("I am %d inches tall.\n", height);

        return 0;
}

Valgrind should produce something like this:

$ valgrind ./ex4
==3082== Memcheck, a memory error detector
==3082== Copyright (C) 2002-2010, and GNU GPL'd, by Julian Seward et al.
==3082== Using Valgrind-3.6.0.SVN-Debian and LibVEX; rerun with -h for copyright info
==3082== Command: ./ex4
==3082== 
I am -16775432 years old.
==3082== Use of uninitialised value of size 8
==3082==    at 0x4E730EB: _itoa_word (_itoa.c:195)
==3082==    by 0x4E743D8: vfprintf (vfprintf.c:1613)
==3082==    by 0x4E7E6F9: printf (printf.c:35)
==3082==    by 0x40052B: main (ex4.c:11)
==3082== 
==3082== Conditional jump or move depends on uninitialised value(s)
==3082==    at 0x4E730F5: _itoa_word (_itoa.c:195)
==3082==    by 0x4E743D8: vfprintf (vfprintf.c:1613)
==3082==    by 0x4E7E6F9: printf (printf.c:35)
==3082==    by 0x40052B: main (ex4.c:11)
==3082== 
==3082== Conditional jump or move depends on uninitialised value(s)
==3082==    at 0x4E7633B: vfprintf (vfprintf.c:1613)
==3082==    by 0x4E7E6F9: printf (printf.c:35)
==3082==    by 0x40052B: main (ex4.c:11)
==3082== 
==3082== Conditional jump or move depends on uninitialised value(s)
==3082==    at 0x4E744C6: vfprintf (vfprintf.c:1613)
==3082==    by 0x4E7E6F9: printf (printf.c:35)
==3082==    by 0x40052B: main (ex4.c:11)
==3082== 
I am 0 inches tall.
==3082== 
==3082== HEAP SUMMARY:
==3082==     in use at exit: 0 bytes in 0 blocks
==3082==   total heap usage: 0 allocs, 0 frees, 0 bytes allocated
==3082== 
==3082== All heap blocks were freed -- no leaks are possible
==3082== 
==3082== For counts of detected and suppressed errors, rerun with: -v
==3082== Use --track-origins=yes to see where uninitialised values come from
==3082== ERROR SUMMARY: 4 errors from 4 contexts (suppressed: 4 from 4)
$

Mine mentions nothing about the errors:

$ valgrind ./ex4
==4098== Memcheck, a memory error detector
==4098== Copyright (C) 2002-2012, and GNU GPL'd, by Julian Seward et al.
==4098== Using Valgrind-3.8.1 and LibVEX; rerun with -h for copyright info
==4098== Command: ./ex4
==4098== 
I am -16776056 years old.
I am 0 inches tall.
==4098== 
==4098== HEAP SUMMARY:
==4098==     in use at exit: 0 bytes in 0 blocks
==4098==   total heap usage: 0 allocs, 0 frees, 0 bytes allocated
==4098== 
==4098== All heap blocks were freed -- no leaks are possible
==4098== 
==4098== For counts of detected and suppressed errors, rerun with: -v
==4098== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 2 from 2)

Answer 1

I am assuming you are using the gcc compiler.

I just gave that a little testing and my valgrind did report the errors only when I had the program built with -O0. With optimizations on (-O3) valgrind did not report the errors. I suppose that would be because the compiler is able to remove the uninitialized jump because the value never changes and is removed entirely. Since you are doing that for exercise you might try to figure out which compiler options work for you. In case you don't know yet what that is, look for "Debug" or "Release" build and switch to "Debug".

HTH, Moose