Implement -Wno-maybe-uninitialized

From-SVN: r172978

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 29296bd632a64468be72bac5f253f0679bd2300c..248ba57fa80dd1471d8c50ac823a47004e53fb7e 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,16 @@
+2011-04-26  Xinliang David Li  <davidxl@google.com>
+
+       * tree-ssa-uninit.c (warn_uninitialized_phi): Pass
+        warning code.
+       * c-family/c-opts.c (c_common_handle_option): Set
+       warn_maybe_uninitialized.
+       * opts.c (common_handle_option): Ditto.
+       * common.opt:  New option.
+       * tree-ssa.c (warn_uninit): Add one more parameter.
+       (warn_uninitialized_var): Pass warning code.
+       * tree-flow.h: Interface change.
+
+
 2011-04-26  Rainer Orth  <ro@CeBiTec.Uni-Bielefeld.DE>
 
        * config/mips/iris6.h (LOCAL_LABEL_PREFIX): Don't test

diff --git a/gcc/c-family/c-opts.c b/gcc/c-family/c-opts.c
index dd87591e6c87dfc4469ec07daaa64571adf0600a..3cd3e56ff3ae9e915d8b563602ae5136b7f0302a 100644 (file)
--- a/gcc/c-family/c-opts.c
+++ b/gcc/c-family/c-opts.c
@@ -384,6 +384,7 @@ c_common_handle_option (size_t scode, const char *arg, int value,
       warn_unknown_pragmas = value;
 
       warn_uninitialized = value;
+      warn_maybe_uninitialized = value;
 
       if (!c_dialect_cxx ())
        {

diff --git a/gcc/common.opt b/gcc/common.opt
index 83a61fc3312aa01ed01d5c60307c2483eb6698ed..ebc2ba7dbf8723f4b98fa860ba693eb72f032eb8 100644 (file)
--- a/gcc/common.opt
+++ b/gcc/common.opt
@@ -631,6 +631,10 @@ Wuninitialized
 Common Var(warn_uninitialized) Init(-1) Warning
 Warn about uninitialized automatic variables
 
+Wmaybe-uninitialized
+Common Var(warn_maybe_uninitialized) Warning
+Warn about maybe uninitialized automatic variables
+
 Wunreachable-code
 Common Ignore
 Does nothing. Preserved for backward compatibility.

diff --git a/gcc/doc/invoke.texi b/gcc/doc/invoke.texi
index 4377f346c7b9021630a3cf04ff9514d50b52b900..98513fb6944ba0e04668cfc9d727ebd93a60207d 100644 (file)
--- a/gcc/doc/invoke.texi
+++ b/gcc/doc/invoke.texi
@@ -246,11 +246,11 @@ Objective-C and Objective-C++ Dialects}.
 -Wformat-security  -Wformat-y2k @gol
 -Wframe-larger-than=@var{len} -Wjump-misses-init -Wignored-qualifiers @gol
 -Wimplicit  -Wimplicit-function-declaration  -Wimplicit-int @gol
--Winit-self  -Winline @gol
+-Winit-self  -Winline -Wmaybe-uninitialized @gol
 -Wno-int-to-pointer-cast -Wno-invalid-offsetof @gol
 -Winvalid-pch -Wlarger-than=@var{len}  -Wunsafe-loop-optimizations @gol
 -Wlogical-op -Wlong-long @gol
--Wmain  -Wmissing-braces  -Wmissing-field-initializers @gol
+-Wmain -Wmaybe-uninitialized -Wmissing-braces  -Wmissing-field-initializers @gol
 -Wmissing-format-attribute  -Wmissing-include-dirs @gol
 -Wno-mudflap @gol
 -Wno-multichar  -Wnonnull  -Wno-overflow @gol
@@ -2946,6 +2946,7 @@ Options} and @ref{Objective-C and Objective-C++ Dialect Options}.
 -Wcomment  @gol
 -Wformat   @gol
 -Wmain @r{(only for C/ObjC and unless} @option{-ffreestanding}@r{)}  @gol
+-Wmaybe-uninitialized @gol
 -Wmissing-braces  @gol
 -Wnonnull  @gol
 -Wparentheses  @gol
@@ -3530,8 +3531,15 @@ to compute a value that itself is never used, because such
 computations may be deleted by data flow analysis before the warnings
 are printed.
 
-These warnings are made optional because GCC is not smart
-enough to see all the reasons why the code might be correct
+@item -Wmaybe-uninitialized
+@opindex Wmaybe-uninitialized
+@opindex Wno-maybe-uninitialized
+For an automatic 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 the variable is not initialized, the compiler will
+emit a warning if it can not prove the uninitialized paths do not
+happen at runtime. These warnings are made optional because GCC is 
+not smart enough to see all the reasons why the code might be correct
 despite appearing to have an error.  Here is one example of how
 this can happen:
 
@@ -3554,20 +3562,9 @@ this can happen:
 
 @noindent
 If the value of @code{y} is always 1, 2 or 3, then @code{x} is
-always initialized, but GCC doesn't know this.  Here is
-another common case:
-
-@smallexample
-@{
-  int save_y;
-  if (change_y) save_y = y, y = new_y;
-  @dots{}
-  if (change_y) y = save_y;
-@}
-@end smallexample
-
-@noindent
-This has no bug because @code{save_y} is used only if it is set.
+always initialized, but GCC doesn't know this. To suppress the
+warning, the user needs to provide a default case with assert(0) or
+similar code.
 
 @cindex @code{longjmp} warnings
 This option also warns when a non-volatile automatic variable might be

diff --git a/gcc/opts.c b/gcc/opts.c
index cd581f6ce6926c424e4e10e37c8705e0076895f0..f00e1b2a6df14de4ba5271a0a060a1eda0171e03 100644 (file)
--- a/gcc/opts.c
+++ b/gcc/opts.c
@@ -1680,6 +1680,11 @@ common_handle_option (struct gcc_options *opts,
       /* No-op. Used by the driver and passed to us because it starts with f.*/
       break;
 
+    case OPT_Wuninitialized:
+      /* Also turn on maybe uninitialized warning.  */
+      warn_maybe_uninitialized = value;
+      break;
+
     default:
       /* If the flag was handled in a standard way, assume the lack of
         processing here is intentional.  */
@@ -1958,6 +1963,9 @@ enable_warning_as_error (const char *arg, int value, unsigned int lang_mask,
       control_warning_option (option_index, (int) kind, value,
                              loc, lang_mask,
                              handlers, opts, opts_set, dc);
+      if (option_index == OPT_Wuninitialized)
+        enable_warning_as_error ("maybe-uninitialized", value, lang_mask,
+                                handlers, opts, opts_set, loc, dc);
     }
   free (new_option);
 }

diff --git a/gcc/testsuite/ChangeLog b/gcc/testsuite/ChangeLog
index 3630dcef68b3756c8194134a39dbf404ba5b0c0a..8b00f7ae3b930f54c64108e20ffced39aac36f53 100644 (file)
--- a/gcc/testsuite/ChangeLog
+++ b/gcc/testsuite/ChangeLog
@@ -1,3 +1,8 @@
+2011-04-26  Xinliang David Li  <davidxl@google.com>
+       
+       * gcc.dg/uninit-suppress.c: New test.
+       * gcc.dg/uninit-suppress.c: New test.
+
 2011-04-26  Jakub Jelinek  <jakub@redhat.com>
 
        PR debug/48768

diff --git a/gcc/testsuite/gcc.dg/uninit-suppress.c b/gcc/testsuite/gcc.dg/uninit-suppress.c
new file mode 100644 (file)
index 0000000..64038a3
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/uninit-suppress.c
@@ -0,0 +1,16 @@
+/* { dg-do compile } */
+/* { dg-options "-fno-tree-ccp -O2 -Wuninitialized -Wno-maybe-uninitialized" } */
+void blah();
+int gflag;
+
+void foo()
+{
+   int v;
+   if (gflag)
+     v = 10;
+
+   blah(); /* *gflag may be killed, but compiler won't know */
+
+   if (gflag)
+    bar(v);   /* { dg-bogus "uninitialized" "should be suppressed" } */
+}

diff --git a/gcc/testsuite/gcc.dg/uninit-suppress_2.c b/gcc/testsuite/gcc.dg/uninit-suppress_2.c
new file mode 100644 (file)
index 0000000..a48b182
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/uninit-suppress_2.c
@@ -0,0 +1,16 @@
+/* { dg-do compile } */
+/* { dg-options "-fno-tree-ccp -O2 -Wuninitialized -Werror=uninitialized -Wno-error=maybe-uninitialized" } */
+void blah();
+int gflag;
+
+void foo()
+{
+   int v;
+   if (gflag)
+     v = 10;
+
+   blah(); /* *gflag may be killed, but compiler won't know */
+
+   if (gflag)
+    bar(v);   /* { dg-warning "uninitialized" "should not be promoted to error" } */
+}

diff --git a/gcc/tree-flow.h b/gcc/tree-flow.h
index a2fa425d2f4c887f7ad5318371d06700dd223644..2ac2bbb66f51d85e678195ee627b90a5e8c89a89 100644 (file)
--- a/gcc/tree-flow.h
+++ b/gcc/tree-flow.h
@@ -546,7 +546,7 @@ extern void flush_pending_stmts (edge);
 extern void verify_ssa (bool);
 extern void delete_tree_ssa (void);
 extern bool ssa_undefined_value_p (tree);
-extern void warn_uninit (tree, const char *, void *);
+extern void warn_uninit (enum opt_code, tree, const char *, void *);
 extern unsigned int warn_uninitialized_vars (bool);
 extern void execute_update_addresses_taken (void);
 

diff --git a/gcc/tree-ssa-uninit.c b/gcc/tree-ssa-uninit.c
index 479ffce5ed79833a9fafcc3fb3d7bfd35db8e71c..7ddce32a62fa7a9b7c2542263df62680bec946ec 100644 (file)
--- a/gcc/tree-ssa-uninit.c
+++ b/gcc/tree-ssa-uninit.c
@@ -1953,7 +1953,7 @@ warn_uninitialized_phi (gimple phi, VEC(gimple, heap) **worklist,
     return;
 
   uninit_op = gimple_phi_arg_def (phi, MASK_FIRST_SET_BIT (uninit_opnds));
-  warn_uninit (uninit_op,
+  warn_uninit (OPT_Wmaybe_uninitialized, uninit_op,
                "%qD may be used uninitialized in this function",
                uninit_use_stmt);
 

diff --git a/gcc/tree-ssa.c b/gcc/tree-ssa.c
index 7f0a077b0444e021323db350707b8d8ff3a27fe2..9ae280a7e32a9d51656b4edfcee22c5a9109163c 100644 (file)
--- a/gcc/tree-ssa.c
+++ b/gcc/tree-ssa.c
@@ -1617,10 +1617,11 @@ walk_use_def_chains (tree var, walk_use_def_chains_fn fn, void *data,
    changed conditionally uninitialized to unconditionally uninitialized.  */
 
 /* Emit a warning for T, an SSA_NAME, being uninitialized.  The exact
-   warning text is in MSGID and LOCUS may contain a location or be null.  */
+   warning text is in MSGID and LOCUS may contain a location or be null.
+   WC is the warning code.  */
 
 void
-warn_uninit (tree t, const char *gmsgid, void *data)
+warn_uninit (enum opt_code wc, tree t, const char *gmsgid, void *data)
 {
   tree var = SSA_NAME_VAR (t);
   gimple context = (gimple) data;
@@ -1644,7 +1645,7 @@ warn_uninit (tree t, const char *gmsgid, void *data)
             : DECL_SOURCE_LOCATION (var);
   xloc = expand_location (location);
   floc = expand_location (DECL_SOURCE_LOCATION (cfun->decl));
-  if (warning_at (location, OPT_Wuninitialized, gmsgid, var))
+  if (warning_at (location, wc, gmsgid, var))
     {
       TREE_NO_WARNING (var) = 1;
 
@@ -1726,10 +1727,12 @@ warn_uninitialized_var (tree *tp, int *walk_subtrees, void *data_)
       /* We only do data flow with SSA_NAMEs, so that's all we
         can warn about.  */
       if (data->always_executed)
-        warn_uninit (t, "%qD is used uninitialized in this function",
+        warn_uninit (OPT_Wuninitialized,
+                    t, "%qD is used uninitialized in this function",
                     data->stmt);
       else if (data->warn_possibly_uninitialized)
-        warn_uninit (t, "%qD may be used uninitialized in this function",
+        warn_uninit (OPT_Wuninitialized,
+                    t, "%qD may be used uninitialized in this function",
                     data->stmt);
       *walk_subtrees = 0;
       break;