[PATCH] VRP comments cleanup

[Richard Biener <rguenther at suse dot de>]

This removes traces of "overflow infinity" from VRP comments and one
unreachable case.

Bootstrap / regtest running on x86_64-unknown-linux-gnu.

Richard.

2017-05-09  Richard Biener  <rguenther@suse.de>

	* tree-vrp.c (vrp_val_is_max): Adjust comment.
	(vrp_val_is_min): Likewise.
	(set_value_range_to_value): Likewise.
	(set_value_range_to_nonnegative): Likewise.
	(gimple_assign_nonzero_p): Likewise.
	(gimple_stmt_nonzero_p): Likewise.
	(vrp_int_const_binop): Likewise.  Remove unreachable case.
	(adjust_range_with_scev): Adjust comments.
	(compare_range_with_value): Likewise.
	(extract_range_from_phi_node): Likewise.
	(test_for_singularity): Likewise.

Index: gcc/tree-vrp.c
===================================================================
--- gcc/tree-vrp.c	(revision 247781)
+++ gcc/tree-vrp.c	(working copy)
@@ -185,11 +185,10 @@ vrp_val_min (const_tree type)
   return TYPE_MIN_VALUE (type);
 }
 
-/* Return whether VAL is equal to the maximum value of its type.  This
-   will be true for a positive overflow infinity.  We can't do a
-   simple equality comparison with TYPE_MAX_VALUE because C typedefs
-   and Ada subtypes can produce types whose TYPE_MAX_VALUE is not ==
-   to the integer constant with the same value in the type.  */
+/* Return whether VAL is equal to the maximum value of its type.
+   We can't do a simple equality comparison with TYPE_MAX_VALUE because
+   C typedefs and Ada subtypes can produce types whose TYPE_MAX_VALUE
+   is not == to the integer constant with the same value in the type.  */
 
 static inline bool
 vrp_val_is_max (const_tree val)
@@ -200,8 +199,7 @@ vrp_val_is_max (const_tree val)
 	      && operand_equal_p (val, type_max, 0)));
 }
 
-/* Return whether VAL is equal to the minimum value of its type.  This
-   will be true for a negative overflow infinity.  */
+/* Return whether VAL is equal to the minimum value of its type.  */
 
 static inline bool
 vrp_val_is_min (const_tree val)
@@ -412,8 +410,7 @@ copy_value_range (value_range *to, value
 
 /* Set value range VR to a single value.  This function is only called
    with values we get from statements, and exists to clear the
-   TREE_OVERFLOW flag so that we don't think we have an overflow
-   infinity when we shouldn't.  */
+   TREE_OVERFLOW flag.  */
 
 static inline void
 set_value_range_to_value (value_range *vr, tree val, bitmap equiv)
@@ -424,11 +421,7 @@ set_value_range_to_value (value_range *v
   set_value_range (vr, VR_RANGE, val, val, equiv);
 }
 
-/* Set value range VR to a non-negative range of type TYPE.
-   OVERFLOW_INFINITY indicates whether to use an overflow infinity
-   rather than TYPE_MAX_VALUE; this should be true if we determine
-   that the range is nonnegative based on the assumption that signed
-   overflow does not occur.  */
+/* Set value range VR to a non-negative range of type TYPE.  */
 
 static inline void
 set_value_range_to_nonnegative (value_range *vr, tree type)
@@ -853,10 +846,7 @@ symbolic_range_based_on_p (value_range *
   return (min_has_symbol || max_has_symbol);
 }
 
-/* Return true if the result of assignment STMT is know to be non-zero.
-   If the return value is based on the assumption that signed overflow is
-   undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't change
-   *STRICT_OVERFLOW_P.*/
+/* Return true if the result of assignment STMT is know to be non-zero.  */
 
 static bool
 gimple_assign_nonzero_p (gimple *stmt)
@@ -888,10 +878,7 @@ gimple_assign_nonzero_p (gimple *stmt)
     }
 }
 
-/* Return true if STMT is known to compute a non-zero value.
-   If the return value is based on the assumption that signed overflow is
-   undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't change
-   *STRICT_OVERFLOW_P.*/
+/* Return true if STMT is known to compute a non-zero value.  */
 
 static bool
 gimple_stmt_nonzero_p (gimple *stmt)
@@ -1610,10 +1597,11 @@ extract_range_from_ssa_name (value_range
 }
 
 
-/* Wrapper around int_const_binop.  If the operation overflows and we
-   are not using wrapping arithmetic, then adjust the result to be
-   -INF or +INF depending on CODE, VAL1 and VAL2.  This can return
-   NULL_TREE for division by zero.  */
+/* Wrapper around int_const_binop.  If the operation overflows and
+   overflow is undefined, then adjust the result to be
+   -INF or +INF depending on CODE, VAL1 and VAL2.  Sets *OVERFLOW_P
+   to whether the operation overflowed.  For division by zero
+   the result is indeterminate but *OVERFLOW_P is set.  */
 
 static wide_int
 vrp_int_const_binop (enum tree_code code, tree val1, tree val2,
@@ -1699,9 +1687,8 @@ vrp_int_const_binop (enum tree_code code
   if (overflow
       && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (val1)))
     {
-      /* If the operation overflowed but neither VAL1 nor VAL2 are
-	 overflown, return -INF or +INF depending on the operation
-	 and the combination of signs of the operands.  */
+      /* If the operation overflowed return -INF or +INF depending
+	 on the operation and the combination of signs of the operands.  */
       int sgn1 = tree_int_cst_sgn (val1);
       int sgn2 = tree_int_cst_sgn (val2);
 
@@ -1727,11 +1714,6 @@ vrp_int_const_binop (enum tree_code code
 	     as positive here, for the corner case 0 - (-INF), which
 	     overflows, but must yield +INF.  */
 	  || (code == MINUS_EXPR && sgn1 >= 0)
-	  /* We only get in here with positive shift count, so the
-	     overflow direction is the same as the sign of val1.
-	     Actually rshift does not overflow at all, but we only
-	     handle the case of shifting overflowed -INF and +INF.  */
-	  || (code == RSHIFT_EXPR && sgn1 >= 0)
 	  /* For division, the only case is -INF / -1 = +INF.  */
 	  || code == TRUNC_DIV_EXPR
 	  || code == FLOOR_DIV_EXPR
@@ -4015,11 +3997,6 @@ adjust_range_with_scev (value_range *vr,
 				get_chrec_loop (chrec), true))
     return;
 
-  /* We use TYPE_MIN_VALUE and TYPE_MAX_VALUE here instead of
-     negative_overflow_infinity and positive_overflow_infinity,
-     because we have concluded that the loop probably does not
-     wrap.  */
-
   type = TREE_TYPE (var);
   if (POINTER_TYPE_P (type) || !TYPE_MIN_VALUE (type))
     tmin = lower_bound_in_type (type, type);
@@ -4164,8 +4141,8 @@ adjust_range_with_scev (value_range *vr,
    - Return NULL_TREE if it is not always possible to determine the
      value of the comparison.
 
-   Also set *STRICT_OVERFLOW_P to indicate whether a range with an
-   overflow infinity was used in the test.  */
+   Also set *STRICT_OVERFLOW_P to indicate whether comparision evaluation
+   assumed signed overflow is undefined.  */
 
 
 static tree
@@ -4305,8 +4282,8 @@ compare_ranges (enum tree_code comp, val
    values in VR.  Return BOOLEAN_FALSE_NODE if the comparison
    always returns false.  Return NULL_TREE if it is not always
    possible to determine the value of the comparison.  Also set
-   *STRICT_OVERFLOW_P to indicate whether a range with an overflow
-   infinity was used in the test.  */
+   *STRICT_OVERFLOW_P to indicate whether comparision evaluation
+   assumed signed overflow is undefined.  */
 
 static tree
 compare_range_with_value (enum tree_code comp, value_range *vr, tree val,
@@ -7246,7 +7223,7 @@ compare_name_with_value (enum tree_code
    ranges equivalent to N1 against all the ranges equivalent to N2
    to determine the value of N1 COMP N2.  Return the same value
    returned by compare_ranges.  Set *STRICT_OVERFLOW_P to indicate
-   whether we relied on an overflow infinity in the comparison.  */
+   whether we relied on undefined signed overflow in the comparison.  */
 
 
 static tree
@@ -8952,7 +8929,7 @@ extract_range_from_phi_node (gphi *phi,
   /* To prevent infinite iterations in the algorithm, derive ranges
      when the new value is slightly bigger or smaller than the
      previous one.  We don't do this if we have seen a new executable
-     edge; this helps us avoid an overflow infinity for conditionals
+     edge; this helps us avoid an infinity for conditionals
      which are not in a loop.  If the old value-range was VR_UNDEFINED
      use the updated range and iterate one more time.  If we will not
      simulate this PHI again via the backedge allow us to iterate.  */
@@ -9476,8 +9453,6 @@ test_for_singularity (enum tree_code con
      written.  */
   if (cond_code == LE_EXPR || cond_code == LT_EXPR)
     {
-      /* This should not be negative infinity; there is no overflow
-	 here.  */
       min = TYPE_MIN_VALUE (TREE_TYPE (op0));
 
       max = op1;
@@ -9492,8 +9467,6 @@ test_for_singularity (enum tree_code con
     }
   else if (cond_code == GE_EXPR || cond_code == GT_EXPR)
     {
-      /* This should not be positive infinity; there is no overflow
-	 here.  */
       max = TYPE_MAX_VALUE (TREE_TYPE (op0));
 
       min = op1;