Attachment 10181 Details for Bug 24639 – Proposed patch and new testcases

[patch] Proposed patch and new testcases

PATCH (text/plain), 9.99 KB, created by Jeffrey A. Law on 2005-11-09 00:02:55 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Jeffrey A. Law

Created: 2005-11-09 00:02:55 UTC

Size: 9.99 KB

patch

obsolete

>	* doc/invoke.texi: Document -Wuninitialized=1 and -Wuninitialized=2.
>	* gcc/opts.c (decode_options): Adjust code which determines if
>	a warning for using -Wuninitialized without -O is needed.
>	(set_Wextra): Adjust setting of warn_uninitialized.
>	* gcc/c-opts.c (c_common_handle_option, case OPT_Wall): Adjust
>	setting of warn_uninitialized.
>	* common.opt (Wuninitialized=): New warning option.
>	* tree-ssa.c (warn_uninitialized_stmts): New.  Extracted rom
>	execute_early_warn_uninitialized.
>	(warn_uninitialized_phis): New.  Extracted from 
>	execute_late_warn_uninitialized.
>	(execute_early_warn_uninitialized): Simplify.  Call
>	warn_uninitialized_phis if user has requested additional
>	uninitialized warnings.
>	(execute_late_warn_uninitialized): Simplify.
>
>	* gcc.dg/pr18501.c: Use -Wuninitialized=2 and remove xfail.
>	* gcc.dg/uninit-J.c: New test.
>	* gcc.dg/uninit-K.c: New test.
>	* gcc.dg/uninit-L.c: New test.
>	* gcc.dg/uninit-M.c: New test.
>	* gcc.dg/uninit-N.c: New test.
>
>Index: gcc/doc/invoke.texi
>===================================================================
>--- gcc/doc/invoke.texi	(revision 106605)
>+++ gcc/doc/invoke.texi	(working copy)
>@@ -2733,6 +2733,19 @@
> 
> This warning is enabled by @option{-Wall}.
> 
>+@item -Wuninitialized=1
>+@opindex Wuninitialized=1
>+This is a synonym for @option{-Wuninitialized}.
>+
>+@item -Wuninitialized=2
>+@opindex Wuninitialized=2
>+Similar to @option{-Wuninitialized} except that it generates warnings for
>+uninitialized variables before optimizing the program.  Use this option
>+to generate uninitialized warnings when the uninitialized use occurs in
>+unreachable or dead code.  This option will also generate spurious
>+uninitialized warnings in cases where optimization analysis would normally
>+prove the variable is always initialized.
>+
> @item -Wunknown-pragmas
> @opindex Wunknown-pragmas
> @cindex warning for unknown pragmas
>Index: gcc/testsuite/gcc.dg/pr18501.c
>===================================================================
>--- gcc/testsuite/gcc.dg/pr18501.c	(revision 106605)
>+++ gcc/testsuite/gcc.dg/pr18501.c	(working copy)
>@@ -1,7 +1,7 @@
> /* Expected uninitialized variable warning.  */
> 
> /* { dg-do compile } */
>-/* { dg-options "-O -Wuninitialized" } */
>+/* { dg-options "-O -Wuninitialized=2" } */
> 
> unsigned bmp_iter_set ();
> int something (void);
>@@ -9,7 +9,7 @@
> void
> bitmap_print_value_set (void)
> {
>-  unsigned first;	/* { dg-warning "may be used" "conditional in loop" { xfail *-*-* } } */
>+  unsigned first;	/* { dg-warning "may be used" "conditional in loop" } */
>   
>   for (; bmp_iter_set (); )
>     {
>Index: gcc/opts.c
>===================================================================
>--- gcc/opts.c	(revision 106605)
>+++ gcc/opts.c	(working copy)
>@@ -663,9 +663,9 @@
>       warn_inline = 0;
> 
>       /* The c_decode_option function and decode_option hook set
>-	 this to `2' if -Wall is used, so we can avoid giving out
>+	 this to `-1' if -Wall is used, so we can avoid giving out
> 	 lots of errors for people who don't realize what -Wall does.  */
>-      if (warn_uninitialized == 1)
>+      if (warn_uninitialized == 1 || warn_uninitialized == 2)
> 	warning (OPT_Wuninitialized,
> 		 "-Wuninitialized is not supported without -O");
>     }
>@@ -1090,8 +1090,8 @@
>      warning about not using it without also specifying -O.  */
>   if (setting == 0)
>     warn_uninitialized = 0;
>-  else if (warn_uninitialized != 1)
>-    warn_uninitialized = 2;
>+  else if (warn_uninitialized != 1 && warn_uninitialized != 2)
>+    warn_uninitialized = -1;
> }
> 
> /* Initialize unused warning flags.  */
>Index: gcc/c-opts.c
>===================================================================
>--- gcc/c-opts.c	(revision 106605)
>+++ gcc/c-opts.c	(working copy)
>@@ -394,8 +394,8 @@
>       /* We save the value of warn_uninitialized, since if they put
> 	 -Wuninitialized on the command line, we need to generate a
> 	 warning about not using it without also specifying -O.  */
>-      if (warn_uninitialized != 1)
>-	warn_uninitialized = (value ? 2 : 0);
>+      if (warn_uninitialized != 1 && warn_uninitialized != 2)
>+	warn_uninitialized = (value ? -1 : 0);
> 
>       if (!c_dialect_cxx ())
> 	/* We set this to 2 here, but 1 in -Wmain, so -ffreestanding
>Index: gcc/common.opt
>===================================================================
>--- gcc/common.opt	(revision 106605)
>+++ gcc/common.opt	(working copy)
>@@ -145,6 +145,10 @@
> Common Var(warn_uninitialized)
> Warn about uninitialized automatic variables
> 
>+Wuninitialized=
>+Common Var(warn_uninitialized) Joined UInteger
>+Generate additional uninitialized automatic variable warnings
>+
> Wunreachable-code
> Common Var(warn_notreached)
> Warn about code that will never be executed
>Index: gcc/tree-ssa.c
>===================================================================
>--- gcc/tree-ssa.c	(revision 106605)
>+++ gcc/tree-ssa.c	(working copy)
>@@ -1186,8 +1186,11 @@
>     }
> }
> 
>+/* Search through all the statements and warn if any use of an
>+   uninitialized variable is found.  */
>+
> static void
>-execute_early_warn_uninitialized (void)
>+warn_uninitialized_stmts (void)
> {
>   block_stmt_iterator bsi;
>   basic_block bb;
>@@ -1201,20 +1204,67 @@
>       }
> }
> 
>+/* Search through all the PHIs any which may reference an 
>+   uninitialized variable.  Warn if any such PHI is found.  */
>+
> static void
>-execute_late_warn_uninitialized (void)
>+warn_uninitialized_phis (void)
> {
>   basic_block bb;
>   tree phi;
> 
>+  FOR_EACH_BB (bb)
>+    for (phi = phi_nodes (bb); phi; phi = PHI_CHAIN (phi))
>+      warn_uninitialized_phi (phi);
>+}
>+
>+/* This pass emits warnings for uninitialized variables before any
>+   optimization occurs.
>+
>+   We always identify and warn for variables which can be trivially
>+   determined are uninitialized at one or more uses.
>+
>+   We conditionally warn for "may be" uninitialized variables at this
>+   time as well (dependent on user flags). 
>+
>+   By emitting "may be" warnings before optimization we can get warnings
>+   for uninitialized variables in which uses are optimized away or 
>+   unreachable.  However, we get more false positive "may be" uninitialized
>+   warnings and some "may be" uninitialized warnings which really should
>+   be "is" uninitialized warnings.  */
>+
>+static void
>+execute_early_warn_uninitialized (void)
>+{
>+  warn_uninitialized_stmts ();
>+
>+  /* If explicitly requested, look for "may be" uninitialized variables
>+     before optimizations as well.  */
>+  if (warn_uninitialized == 2)
>+    warn_uninitialized_phis ();
>+}
>+
>+/* This pass emits warnings for uninitialized variables after 
>+   optimization has been performed.
>+
>+   By delaying warnings until after optimization we can turn more
>+   "may be" uninitialized warnings into "is" uninitialized warnings.
>+   We can also eliminate some false positive "may be" uninitialized
>+   warnings. 
>+
>+   This pass also emits warnings for any variables exposed by the
>+   optimizers.  For example, if optimization removed the need to
>+   take the address of a variable, then this pass will be the only
>+   chance we have to get uninitialized warnings for such variables.  */
>+static void
>+execute_late_warn_uninitialized (void)
>+{
>   /* Re-do the plain uninitialized variable check, as optimization may have
>      straightened control flow.  Do this first so that we don't accidentally
>      get a "may be" warning when we'd have seen an "is" warning later.  */
>-  execute_early_warn_uninitialized ();
>+  warn_uninitialized_stmts ();
> 
>-  FOR_EACH_BB (bb)
>-    for (phi = phi_nodes (bb); phi; phi = PHI_CHAIN (phi))
>-      warn_uninitialized_phi (phi);
>+  warn_uninitialized_phis ();
> }
> 
> static bool
>*** /dev/null	Wed Sep 28 10:04:49 2005
>--- gcc/testsuite/gcc.dg/uninit-J.c	Tue Nov  8 09:58:09 2005
>***************
>*** 0 ****
>--- 1,27 ----
>+ /* PR 5035 */
>+ /* { dg-do compile } */
>+ /* { dg-options "-O2 -Wall -Werror" } */
>+ extern int f(void);
>+ 
>+ 
>+ int main(void)
>+ {
>+    int a, b, c; /* { dg-bogus "b" "uninitialized variable warning" } */
>+ 
>+    a = f();
>+    
>+    if (a)
>+    {
>+        b = 10;
>+    }
>+ 
>+    if (f())
>+    {
>+        c = 151;
>+    }
>+ 
>+    if (a)
>+        return b;
>+    return 0;
>+ }
>+ 
>*** /dev/null	Wed Sep 28 10:04:49 2005
>--- gcc/testsuite/gcc.dg/uninit-K.c	Tue Nov  8 15:41:35 2005
>***************
>*** 0 ****
>--- 1,19 ----
>+ /* PR 19371 */
>+ /* Expected uninitialized variable warning.  */
>+ 
>+ /* { dg-do compile } */
>+ /* { dg-options "-O -Wuninitialized=2" } */
>+ int bar(int n) {
>+     return n + 1;
>+ }
>+ 
>+ 
>+ int main(void) {
>+     int a = bar(a); /* { dg-warning "is used uninitialized" } */
>+     int b;
>+     int c;
>+     int d;
>+     b = bar(b); /* { dg-warning "is used uninitialized" } */
>+     (void) bar(c); /* { dg-warning "is used uninitialized" } */
>+     return bar(d); /* { dg-warning "is used uninitialized" } */
>+ }
>*** /dev/null	Wed Sep 28 10:04:49 2005
>--- gcc/testsuite/gcc.dg/uninit-L.c	Tue Nov  8 15:54:00 2005
>***************
>*** 0 ****
>--- 1,20 ----
>+ /* PR 20644 */
>+ /* { dg-do compile } */
>+ /* { dg-options "-O2 -Wall" } */
>+ 
>+ int foo ()
>+ {
>+     int i;
>+     int j;
>+ 
>+     for ( ; ; ) {
>+         i = 0;
>+         if (0 == i)
>+             break;
>+     }
>+ 
>+     if (1 == i)
>+         return j;  /* { dg-bogus "j" "is used uninitialized" { xfail *-*-* } } */
>+ 
>+     return 0;
>+ }
>*** /dev/null	Wed Sep 28 10:04:49 2005
>--- gcc/testsuite/gcc.dg/uninit-M.c	Tue Nov  8 16:10:57 2005
>***************
>*** 0 ****
>--- 1,34 ----
>+ /* PR 20968 */
>+ /* { dg-do compile } */
>+ /* { dg-options "-O2 -Wall" } */
>+ struct {int count;} *v1;
>+ int c;
>+ int k;
>+ 
>+ extern void baz(int);
>+ 
>+ static int bar(int *j)
>+ {
>+     if (k == 4)
>+     {
>+ 	*j = 1;
>+ 	return 1;
>+     }
>+     return 0;
>+ }
>+ 
>+ void foo(void)
>+ {
>+     int i;  /* { dg-bogus "i" "may be used uninitialized" { xfail *-*-* } } */
>+ 
>+     if (!bar(&i))
>+     {
>+ 	if (!c)
>+ 	    return;
>+ 	v1->count++;
>+     }
>+     if (!c)
>+     {
>+ 	baz(i);
>+     }
>+ }
>*** /dev/null	Wed Sep 28 10:04:49 2005
>--- gcc/testsuite/gcc.dg/uninit-N.c	Tue Nov  8 10:58:57 2005
>***************
>*** 0 ****
>--- 1,8 ----
>+ /* PR 22456 */
>+ /* { dg-do compile } */
>+ /* { dg-options "-O2 -Wuninitialized=2" } */
>+ void foo()
>+ {
>+     int i;  /* { dg-warning "may be used" } */
>+     while (i) ++i;
>+ }

Actions: View | Diff

Attachments on bug 24639: 10181