common.opt: Add Wstrict-overflow and Wstrict-overflow=.

./:	* common.opt: Add Wstrict-overflow and Wstrict-overflow=.
	* flags.h (warn_strict_overflow): Declare.
	(enum warn_strict_overflow_code): Define.
	(issue_strict_overflow_warning): New static inline function.
	* opts.c (warn_strict_overflow): New variable.
	(common_handle_option): Handle OPT_Wstrict_overflow and
	OPT_Wstrict_overflow_.
	* c-opts.c (c_common_handle_option): Set warn_strict_overflow for
	OPT_Wall.
	* fold-const.c: Include intl.h.
	(fold_deferring_overflow_warnings): New static variable.
	(fold_deferred_overflow_warning): New static variable.
	(fold_deferred_overflow_code): New static variable.
	(fold_defer_overflow_warnings): New function.
	(fold_undefer_overflow_warnings): New function.
	(fold_undefer_and_ignore_overflow_warnings): New function.
	(fold_deferring_overflow_warnings_p): New function.
	(fold_overflow_warning): New static function.
	(make_range): Add strict_overflow_p parameter.  Change all
	callers.
	(extract_muldiv, extract_muldiv_1): Likewise.
	(fold_unary) [ABS_EXPR]: Check ABS_EXPR before calling
	tree_expr_nonnegative_p.
	(fold_negate_expr): Call fold_overflow_warning.
	(fold_range_test): Likewise.
	(fold_comparison): Likewise.
	(fold_binary): Likewise.  Call tree_expr_nonnegative_warnv_p
	instead of tree_expr_nonnegative_p.
	(tree_expr_nonnegative_warnv_p): Rename from
	tree_expr_nonnegative_p, add strict_overflow_p parameter.
	(tree_expr_nonnegative_p): New function.
	(tree_expr_nonzero_warnv_p): Rename from tree_expr_nonzero_p, add
	strict_overflow_p parameter.
	(tree_expr_nonzero_p): New function.
	* passes.c (verify_interpass_invariants): New static function.
	(execute_one_pass): Call it.
	* tree-ssa-loop-niter.c (expand_simple_operations): Ignore fold
	warnings.
	(number_of_iterations_exit, loop_niter_by_eval): Likewise.
	(estimate_numbers_of_iterations): Likewise.
	(scev_probably_wraps_p): Likewise.
	* tree-ssa-ccp.c: Include "toplev.h".
	(evaluate_stmt): Defer fold overflow warnings until we know we are
	going to optimize.
	(struct fold_stmt_r_data): Add stmt field.
	(fold_stmt_r): Defer fold overflow warnings until we know we
	optimized.
	(fold_stmt): Initialize stmt field of fold_stmt_r_data.
	(fold_stmt_inplace): Likewise.
	* tree-cfgcleanup.c: Include "toplev.h" rather than "errors.h".
	(cleanup_control_expr_graph): Defer fold overflow warnings until
	we know we are going to optimize.
	* tree-cfg.c (fold_cond_expr_cond): Likewise.
	* tree-ssa-threadedge.c (simplify_control_stmt_condition):
	Likewise.
	* tree-vrp.c (vrp_expr_computes_nonnegative): Call
	tree_expr_nonnegative_warnv_p instead of tree_expr_nonnegative_p.
	* tree-ssa-loop-manip.c (create_iv): Likewise.
	* c-typeck.c (build_conditional_expr): Likewise.
	(build_binary_op): Likewise.
	* tree-vrp.c (vrp_expr_computes_nonzero): Call
	tree_expr_nonzero_warnv_p instead of tree_expr_nonzero_p.
	(extract_range_from_unary_expr): Likewise.
	* simplify-rtx.c (simplify_const_relational_operation): Warn when
	assuming that signed overflow does not occur.
	* c-common.c (pointer_int_sum): Ignore fold overflow warnings.
	* tree.h (tree_expr_nonnegative_warnv_p): Declare.
	(fold_defer_overflow_warnings): Declare.
	(fold_undefer_overflow_warnings): Declare.
	(fold_undefer_and_ignore_overflow_warnings): Declare.
	(fold_deferring_overflow_warnings_p): Declare.
	(tree_expr_nonzero_warnv_p): Declare.
	* doc/invoke.texi (Option Summary): Add -Wstrict-overflow to list
	of warning options.
	(Warning Options): Document -Wstrict-overflow.
	* Makefile.in (tree-ssa-threadedge.o): Depend on toplev.h.
	(tree-ssa-ccp.o): Likewise.
	(tree-cfgcleanup.o): Change errors.h dependency to toplev.h.
	(fold-const.o): Depend on intl.h.
testsuite/:
	* gcc.dg/Wstrict-overflow-1.c: New test.
	* gcc.dg/Wstrict-overflow-2.c: New test.
	* gcc.dg/Wstrict-overflow-3.c: New test.
	* gcc.dg/Wstrict-overflow-4.c: New test.
	* gcc.dg/Wstrict-overflow-5.c: New test.
	* gcc.dg/Wstrict-overflow-6.c: New test.
	* gcc.dg/Wstrict-overflow-7.c: New test.
	* gcc.dg/Wstrict-overflow-8.c: New test.
	* gcc.dg/Wstrict-overflow-9.c: New test.
	* gcc.dg/Wstrict-overflow-10.c: New test.

From-SVN: r121895

1 files changed, 45 insertions, 5 deletions

diff --git a/gcc/tree-ssa-loop-niter.c b/gcc/tree-ssa-loop-niter.c
index c2a9f9c..95a9e46 100644
--- a/gcc/tree-ssa-loop-niter.c
+++ b/gcc/tree-ssa-loop-niter.c
@@ -705,7 +705,13 @@ expand_simple_operations (tree expr)
 	  TREE_OPERAND (ret, i) = ee;
 	}
 
-      return (ret ? fold (ret) : expr);
+      if (!ret)
+	return expr;
+
+      fold_defer_overflow_warnings ();
+      ret = fold (ret);
+      fold_undefer_and_ignore_overflow_warnings ();
+      return ret;
     }
 
   if (TREE_CODE (expr) != SSA_NAME)
@@ -1053,11 +1059,18 @@ number_of_iterations_exit (struct loop *loop, edge exit,
   if (!simple_iv (loop, stmt, op1, &iv1, false))
     return false;
 
+  /* We don't want to see undefined signed overflow warnings while
+     computing the nmber of iterations.  */
+  fold_defer_overflow_warnings ();
+
   iv0.base = expand_simple_operations (iv0.base);
   iv1.base = expand_simple_operations (iv1.base);
   if (!number_of_iterations_cond (type, &iv0, code, &iv1, niter,
 				  loop_only_exit_p (loop, exit)))
-    return false;
+    {
+      fold_undefer_and_ignore_overflow_warnings ();
+      return false;
+    }
 
   if (optimize >= 3)
     {
@@ -1078,6 +1091,8 @@ number_of_iterations_exit (struct loop *loop, edge exit,
 					       niter->may_be_zero,
 					       &niter->additional_info);
 
+  fold_undefer_and_ignore_overflow_warnings ();
+
   if (integer_onep (niter->assumptions))
     return true;
 
@@ -1376,6 +1391,9 @@ loop_niter_by_eval (struct loop *loop, edge exit)
 	}
     }
 
+  /* Don't issue signed overflow warnings.  */
+  fold_defer_overflow_warnings ();
+
   for (i = 0; i < MAX_ITERATIONS_TO_TRACK; i++)
     {
       for (j = 0; j < 2; j++)
@@ -1384,6 +1402,7 @@ loop_niter_by_eval (struct loop *loop, edge exit)
       acnd = fold_binary (cmp, boolean_type_node, aval[0], aval[1]);
       if (acnd && integer_zerop (acnd))
 	{
+	  fold_undefer_and_ignore_overflow_warnings ();
 	  if (dump_file && (dump_flags & TDF_DETAILS))
 	    fprintf (dump_file,
 		     "Proved that loop %d iterates %d times using brute force.\n",
@@ -1395,10 +1414,15 @@ loop_niter_by_eval (struct loop *loop, edge exit)
 	{
 	  val[j] = get_val_for (next[j], val[j]);
 	  if (!is_gimple_min_invariant (val[j]))
-	    return chrec_dont_know;
+	    {
+	      fold_undefer_and_ignore_overflow_warnings ();
+	      return chrec_dont_know;
+	    }
 	}
     }
 
+  fold_undefer_and_ignore_overflow_warnings ();
+
   return chrec_dont_know;
 }
 
@@ -1994,10 +2018,16 @@ estimate_numbers_of_iterations (void)
   loop_iterator li;
   struct loop *loop;
 
+  /* We don't want to issue signed overflow warnings while getting
+     loop iteration estimates.  */
+  fold_defer_overflow_warnings ();
+
   FOR_EACH_LOOP (li, loop, 0)
     {
       estimate_numbers_of_iterations_loop (loop);
     }
+
+  fold_undefer_and_ignore_overflow_warnings ();
 }
 
 /* Returns true if statement S1 dominates statement S2.  */
@@ -2153,6 +2183,9 @@ scev_probably_wraps_p (tree base, tree step,
   if (use_overflow_semantics && nowrap_type_p (type))
     return false;
 
+  /* Don't issue signed overflow warnings.  */
+  fold_defer_overflow_warnings ();
+
   /* Otherwise, compute the number of iterations before we reach the
      bound of the type, and verify that the loop is exited before this
      occurs.  */
@@ -2179,8 +2212,15 @@ scev_probably_wraps_p (tree base, tree step,
 
   estimate_numbers_of_iterations_loop (loop);
   for (bound = loop->bounds; bound; bound = bound->next)
-    if (n_of_executions_at_most (at_stmt, bound, valid_niter))
-      return false;
+    {
+      if (n_of_executions_at_most (at_stmt, bound, valid_niter))
+	{
+	  fold_undefer_and_ignore_overflow_warnings ();
+	  return false;
+	}
+    }
+
+  fold_undefer_and_ignore_overflow_warnings ();
 
   /* At this point we still don't have a proof that the iv does not
      overflow: give up.  */