C – GCC Compiler Ignores Uninitialized Variable Warning for Debug Build

c++gccgcc-warning

gcc compiler ignores uninitialized variable warning for debug build. This looks very weird for me, can some one help me to understand this ?

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

int main(int argc, char *argv[])
{
    int i, max;
    int count;
    if (argc < 2) {
        return -1;
    }
    max = atoi(argv[1]);
    for (i = 0; i < max; i++) {
        count++;
    }
    printf("count is %d\n", count);
    return 0;
}

gcc a.c -g -Wall -Werror

No warning

gcc a.c -O3 -Wall -Werror

a.c: In function ‘main’:
a.c:8:9: error: ‘count’ may be used uninitialized in this function [-Werror=maybe-uninitialized]
     int count;
         ^~~~~
cc1: all warnings being treated as errors

gcc version: 7.4.0

Best Answer

Though it may look weird, this behavior is documented for -Wmaybe-uninitialized gcc option:

-Wmaybe-uninitialized

For an automatic (i.e. local) variable, if there exists a path from the function entry to a use of the variable that is initialized, but there exist some other paths for which the variable is not initialized, the compiler emits a warning if it cannot prove the uninitialized paths are not executed at run time.

These warnings are only possible in optimizing compilation, because otherwise GCC does not keep track of the state of variables.

I guess the reason is that the cost of analyzing not initialized variables is too much for not optimizing compilation. That's why it is done only for optimizing one.

Related Solutions

C++ GCC – Variable Not Detected as Not Used in GCC

In theory, the default constructor for std::vector<int> could have arbitrary side effects, so the compiler cannot figure out whether removing the definition of a would change the semantics of the program. You only get those warning for built-in types.

A better example is a lock:

{
    lock a;
    // ...
    // do critical stuff
    // a is never used here
    // ...
    // lock is automatically released by a's destructor (RAII)
}

Even though a is never used after its definition, removing the first line would be wrong.

C++ GCC – How to Disable ‘May Be Used Uninitialized’ Warning for a Variable

The accepted answer has two big problems that requires more than a comment. First, it deactivates the warning for the whole file. If that pragma resides in a header, probably for more. Warnings are useful and if it is indeed a false positive, one should disable the warning for a bunch of code as small as possible.

Then the warning in the OP is "maybe uninitialized" which is deactivated by -Wmaybe-uninitialized, as opposed to -Wuninitialized.

#pragma GCC diagnostic push                             // save the actual diag context
#pragma GCC diagnostic ignored "-Wmaybe-uninitialized"  // disable maybe warnings
function() or int variable;                             // impacted section of code
#pragma GCC diagnostic pop                              // restore previous diag context