PATCH RFC: Fix PR 31602 by not warning for overflow in loop headers

[Ian Lance Taylor <iant at google dot com>]

PR 31602 is about a case where the undefined overflow warning triggers
in a copied loop header.  In general the undefined overflow warning is
not supposed to be issued for loop optimizations.  The loop header
case is one that I missed.

This patch fixes it.  It has been bootstrapped and tested on
i686-pc-linux-gnu.  Unless somebody has some comments on it, I plan to
commit it to mainline and 4.2 branch in a few days.

The patch also clarifies the documentation.  It was already the case
that the overflow warnings are not issued for loop code.  Hence the
calls to fold_undefer_and_ignore_overflow_warnings in
tree-ssa-loop-niter.c.

Ian


gcc/ChangeLog:
2007-04-20  Ian Lance Taylor  <iant@google.com>

	PR tree-optimization/31602
	* tree-ssa-loop-ch.c (copy_loop_headers): Set TREE_NO_WARNING for
	conditionals in the copied loop header.
	* tree-cfg.c (fold_cond_expr_cond): Don't issue undefined overflow
	warnings if TREE_NO_WARNING is set.
	* doc/invoke.texi (Warning Options): Clarify that
	-Wstrict-overflow does not warn about loops.

gcc/testsuite/ChangeLog:
2007-04-20  Ian Lance Taylor  <iant@google.com>

	PR tree-optimization/31602
	* gcc.dg/Wstrict-overflow-11.c: We no longer issue a warning.


Index: gcc/tree-ssa-loop-ch.c
===================================================================
--- gcc/tree-ssa-loop-ch.c	(revision 123905)
+++ gcc/tree-ssa-loop-ch.c	(working copy)
@@ -1,5 +1,5 @@
 /* Loop header copying on trees.
-   Copyright (C) 2004, 2005 Free Software Foundation, Inc.
+   Copyright (C) 2004, 2005, 2006, 2007 Free Software Foundation, Inc.
    
 This file is part of GCC.
    
@@ -200,6 +200,27 @@ copy_loop_headers (void)
 	  continue;
 	}
 
+      /* If the loop has the form "for (i = j; i < j + 10; i++)" then
+	 this copying can introduce a case where we rely on undefined
+	 signed overflow to eliminate the preheader condition, because
+	 we assume that "j < j + 10" is true.  We don't want to warn
+	 about that case for -Wstrict-overflow, because in general we
+	 don't warn about overflow involving loops.  Prevent the
+	 warning by setting TREE_NO_WARNING.  */
+      if (warn_strict_overflow > 0)
+	{
+	  unsigned int i;
+
+	  for (i = 0; i < n_bbs; ++i)
+	    {
+	      tree last;
+
+	      last = last_stmt (copied_bbs[i]);
+	      if (TREE_CODE (last) == COND_EXPR)
+		TREE_NO_WARNING (last) = 1;
+	    }
+	}
+
       /* Ensure that the latch and the preheader is simple (we know that they
 	 are not now, since there was the loop exit condition.  */
       split_edge (loop_preheader_edge (loop));
Index: gcc/tree-cfg.c
===================================================================
--- gcc/tree-cfg.c	(revision 123905)
+++ gcc/tree-cfg.c	(working copy)
@@ -415,7 +415,9 @@ fold_cond_expr_cond (void)
 	  cond = fold (COND_EXPR_COND (stmt));
 	  zerop = integer_zerop (cond);
 	  onep = integer_onep (cond);
-	  fold_undefer_overflow_warnings (zerop || onep, stmt,
+	  fold_undefer_overflow_warnings (((zerop || onep)
+					   && !TREE_NO_WARNING (stmt)),
+					  stmt,
 					  WARN_STRICT_OVERFLOW_CONDITIONAL);
 	  if (zerop)
 	    COND_EXPR_COND (stmt) = boolean_false_node;
Index: gcc/doc/invoke.texi
===================================================================
--- gcc/doc/invoke.texi	(revision 123909)
+++ gcc/doc/invoke.texi	(working copy)
@@ -3029,7 +3029,10 @@ perfectly safe if the values of the vari
 overflow never does, in fact, occur.  Therefore this warning can
 easily give a false positive: a warning about code which is not
 actually a problem.  To help focus on important issues, several
-warning levels are defined.
+warning levels are defined.  No warnings are issued for the use of
+undefined signed overflow when estimating how many iterations a loop
+will require, in particular when determining whether a loop will be
+executed at all.
 
 @table @option
 @item -Wstrict-overflow=1
Index: gcc/testsuite/gcc.dg/Wstrict-overflow-11.c
===================================================================
--- gcc/testsuite/gcc.dg/Wstrict-overflow-11.c	(revision 123905)
+++ gcc/testsuite/gcc.dg/Wstrict-overflow-11.c	(working copy)
@@ -3,14 +3,16 @@
 
 /* Based on strict-overflow-5.c.  */
 
-/* We can only unroll when using strict overflow semantics.  */
+/* We can only unroll when using strict overflow semantics.  But we
+   don't issue a warning for relying on undefined overflow in
+   loops.  */
 
 int foo (int i)
 {
   int index;
   int r=0;
  
-  for (index = i; index <= i+4; index+=2) /* { dg-warning "assuming signed overflow does not occur" "correct warning" } */
+  for (index = i; index <= i+4; index+=2)
     r++;
  
   return r;