There is no "may be used uninitialized" when optimization is disabled - c++

Question

In simple short words:
I need to show "may be used uninitialized" for -O0 optimization
I have problem with cause warning "may be used uninitialized in this function" when optimization is turned off.
I have in code something like this:
int i = i;
Which is obviously wrong. And if compiler optimization is turned off - there is no warning but if I turn optimization to -O1 warring appears.
I need to show this warning when optimizations by -O option are disabled.
Ofcourse there are gcc warning options:
-Wall -Wextra -Winit-self -Wuninitialized -Werror
I read chapter 3.10 Options That Control Optimization, turn off optimization and manually add all -f flags which should be turned on for -O1 level:
-fauto-inc-dec
-fcprop-registers
-fdce
-fdefer-pop
-fdelayed-branch
-fdse
-fguess-branch-probability
-fif-conversion2
-fif-conversion
-fipa-pure-const
-fipa-reference
-fmerge-constants
-fsplit-wide-types
-ftree-builtin-call-dce
-ftree-ccp
-ftree-ch
-ftree-copyrename
-ftree-dce
-ftree-dominator-opts
-ftree-dse
-ftree-forwprop
-ftree-fre
-ftree-phiprop
-ftree-sra
-ftree-pta
-ftree-ter
-funit-at-a-time
and additional:
-fdefer-pop
-fthread-jumps
-fcprop-registers
-fomit-frame-pointer
There is no warning.
Please, could you tell me which flag I missed?
Compiler which I must use is gcc-4.5.4

Answer 1

I think you need:
-Wuninitialized -Winit-self
for that one. Even with -O0, that still generates a warning about self initialisation (at least for gcc 4.7.2):
pax> cat x.c
#include <stdio.h>
int main (void) {
int i = i;
return 0;
}
pax> gcc -O0 -Wuninitialized -Winit-self -o x x.c
x.c: In function ‘main’:
x.c:4:6: warning: ‘i’ is used uninitialized in this function [-Wuninitialized]
If you can't get this happening for your version of gcc, there may be another way. You could change the way you build things so that checks are done first at -O1 and only if they pass do you proceed to do the -O0 build. A Makefile like this should be a good start:
x: x.c
gcc -O1 -Wuninitialized -Winit-self -Werror -o x x.c
gcc -O0 -o x x.c
The first compilation will treat warnings as errors so, if it finds self initialisation, the make process will stop completely.
If there are no warnings, you carry on and build the executable again but with -O0.
That may need tuning to make it so only self initialisation stops the process and they may be a little trickier. But it's something to keep in mind if you need the behaviour and you can't convince your current compiler to give it to you at that optimisation level.
One way would be to simply not use -Werror but instead capture the output of the compiler and search specifically for the string is used uninitialized, returning an error code to your make process. That's a bit of a kludge but you may end up having to do something of that description.