re PR c/19978 (overflow in expression of constants should not cause multiple warnings)

2007-01-05  Manuel Lopez-Ibanez  <manu@gcc.gnu.org>

	PR c/19978
	* tree.h (TREE_OVERFLOW_P): New.
	* c-typeck.c (parser_build_unary_op): Warn only if result
	overflowed and operands did not.
	(parser_build_binary_op): Likewise.
	(convert_for_assignment): Remove redundant overflow_warning.
	* c-common.c (overflow_warning): Don't check or set TREE_OVERFLOW.

cp/
	* semantics.c (finish_unary_op_expr): Warn only if result
	overflowed and operands did not.

testsuite/
	* gcc.dg/multiple-overflow-warn-1.c: New.
	* gcc.dg/multiple-overflow-warn-2.c: New.
	* gcc.dg/overflow-warn-6.c: New.
	* g++.dg/warn/multiple-overflow-warn-1.C: New.

From-SVN: r120505

1 files changed, 31 insertions, 25 deletions

diff --git a/gcc/c-common.c b/gcc/c-common.c
index 1794bd8..8fb9541 100644
--- a/gcc/c-common.c
+++ b/gcc/c-common.c
@@ -920,39 +920,45 @@ constant_expression_warning (tree value)
     pedwarn ("overflow in constant expression");
 }
 
-/* Print a warning if an expression had overflow in folding.
+/* Print a warning if an expression had overflow in folding and its
+   operands hadn't.
+
    Invoke this function on every expression that
    (1) appears in the source code, and
-   (2) might be a constant expression that overflowed, and
+   (2) is a constant expression that overflowed, and
    (3) is not already checked by convert_and_check;
-   however, do not invoke this function on operands of explicit casts.  */
+   however, do not invoke this function on operands of explicit casts
+   or when the expression is the result of an operator and any operand
+   already overflowed.  */
 
 void
 overflow_warning (tree value)
 {
-  if ((TREE_CODE (value) == INTEGER_CST
-       || (TREE_CODE (value) == COMPLEX_CST
-	   && TREE_CODE (TREE_REALPART (value)) == INTEGER_CST))
-      && TREE_OVERFLOW (value))
-    {
-      TREE_OVERFLOW (value) = 0;
-      if (skip_evaluation == 0)
-	warning (OPT_Woverflow, "integer overflow in expression");
-    }
-  else if ((TREE_CODE (value) == REAL_CST
-	    || (TREE_CODE (value) == COMPLEX_CST
-		&& TREE_CODE (TREE_REALPART (value)) == REAL_CST))
-	   && TREE_OVERFLOW (value))
-    {
-      TREE_OVERFLOW (value) = 0;
-      if (skip_evaluation == 0)
-	warning (OPT_Woverflow, "floating point overflow in expression");
-    }
-  else if (TREE_CODE (value) == VECTOR_CST && TREE_OVERFLOW (value))
+  if (skip_evaluation) return;
+
+  switch (TREE_CODE (value))
     {
-      TREE_OVERFLOW (value) = 0;
-      if (skip_evaluation == 0)
-	warning (OPT_Woverflow, "vector overflow in expression");
+    case INTEGER_CST:
+      warning (OPT_Woverflow, "integer overflow in expression");
+      break;
+      
+    case REAL_CST:
+      warning (OPT_Woverflow, "floating point overflow in expression");
+      break;
+      
+    case VECTOR_CST:
+      warning (OPT_Woverflow, "vector overflow in expression");
+      break;
+      
+    case COMPLEX_CST:
+      if (TREE_CODE (TREE_REALPART (value)) == INTEGER_CST)
+	warning (OPT_Woverflow, "complex integer overflow in expression");
+      else if (TREE_CODE (TREE_REALPART (value)) == REAL_CST)
+	warning (OPT_Woverflow, "complex floating point overflow in expression");
+      break;
+
+    default:
+      break;
     }
 }