Always check the return value of fold_range.

The fold_range routine in range-ops returns FALSE if the operation
fails.  There are a few places which assume the operation was
successful.  Fix those.

	* gimple-range-fold.cc (range_of_range_op): Set result to
	VARYING if the call to fold_range fails.
	* tree-data-ref.cc (compute_distributive_range): Ditto.
	* tree-vrp.cc (range_fold_binary_expr): Ditto.
	(range_fold_unary_expr): Ditto.
	* value-query.cc (range_query::get_tree_range): Ditto.

4 files changed, 16 insertions, 8 deletions

diff --git a/gcc/gimple-range-fold.cc b/gcc/gimple-range-fold.cc
index addf3e7..4240825 100644
--- a/gcc/gimple-range-fold.cc
+++ b/gcc/gimple-range-fold.cc
@@ -544,7 +544,8 @@ fold_using_range::range_of_range_op (vrange &r,
 	  // Fold range, and register any dependency if available.
 	  Value_Range r2 (type);
 	  r2.set_varying (type);
-	  handler.fold_range (r, type, range1, r2);
+	  if (!handler.fold_range (r, type, range1, r2))
+	    r.set_varying (type);
 	  if (lhs && gimple_range_ssa_p (op1))
 	    {
 	      if (src.gori ())
@@ -567,7 +568,8 @@ fold_using_range::range_of_range_op (vrange &r,
 	      fputc ('\n', dump_file);
 	    }
 	  // Fold range, and register any dependency if available.
-	  handler.fold_range (r, type, range1, range2, rel);
+	  if (!handler.fold_range (r, type, range1, range2, rel))
+	    r.set_varying (type);
 	  if (irange::supports_p (type))
 	    relation_fold_and_or (as_a <irange> (r), s, src);
 	  if (lhs)
diff --git a/gcc/tree-data-ref.cc b/gcc/tree-data-ref.cc
index ff9327f..91bfb619d 100644
--- a/gcc/tree-data-ref.cc
+++ b/gcc/tree-data-ref.cc
@@ -594,7 +594,8 @@ compute_distributive_range (tree type, value_range &op0_range,
   if (result_range)
     {
       range_op_handler op (code, type);
-      op.fold_range (*result_range, type, op0_range, op1_range);
+      if (!op.fold_range (*result_range, type, op0_range, op1_range))
+	result_range->set_varying (type);
     }
 
   /* The distributive property guarantees that if TYPE is no narrower
@@ -642,7 +643,8 @@ compute_distributive_range (tree type, value_range &op0_range,
   range_op_handler op (code, ssizetype);
   bool saved_flag_wrapv = flag_wrapv;
   flag_wrapv = 1;
-  op.fold_range (wide_range, ssizetype, op0_range, op1_range);
+  if (!op.fold_range (wide_range, ssizetype, op0_range, op1_range))
+    wide_range.set_varying (ssizetype);;
   flag_wrapv = saved_flag_wrapv;
   if (wide_range.num_pairs () != 1 || !range_int_cst_p (&wide_range))
     return false;
diff --git a/gcc/tree-vrp.cc b/gcc/tree-vrp.cc
index c3030a1..93482e5 100644
--- a/gcc/tree-vrp.cc
+++ b/gcc/tree-vrp.cc
@@ -1069,7 +1069,8 @@ range_fold_binary_expr (value_range *vr,
     vr1.set_varying (expr_type);
   vr0.normalize_addresses ();
   vr1.normalize_addresses ();
-  op.fold_range (*vr, expr_type, vr0, vr1);
+  if (!op.fold_range (*vr, expr_type, vr0, vr1))
+    vr->set_varying (expr_type);
 }
 
 /* Perform a unary operation on a range.  */
@@ -1095,7 +1096,8 @@ range_fold_unary_expr (value_range *vr,
 
   value_range vr0_cst (*vr0);
   vr0_cst.normalize_addresses ();
-  op.fold_range (*vr, expr_type, vr0_cst, value_range (expr_type));
+  if (!op.fold_range (*vr, expr_type, vr0_cst, value_range (expr_type)))
+    vr->set_varying (expr_type);
 }
 
 /* If the range of values taken by OP can be inferred after STMT executes,
diff --git a/gcc/value-query.cc b/gcc/value-query.cc
index 0bdd670..296784b 100644
--- a/gcc/value-query.cc
+++ b/gcc/value-query.cc
@@ -252,7 +252,8 @@ range_query::get_tree_range (vrange &r, tree expr, gimple *stmt)
 	  Value_Range r1 (TREE_TYPE (TREE_OPERAND (expr, 1)));
 	  range_of_expr (r0, TREE_OPERAND (expr, 0), stmt);
 	  range_of_expr (r1, TREE_OPERAND (expr, 1), stmt);
-	  op.fold_range (r, type, r0, r1);
+	  if (!op.fold_range (r, type, r0, r1))
+	    r.set_varying (type);
 	}
       else
 	r.set_varying (type);
@@ -268,7 +269,8 @@ range_query::get_tree_range (vrange &r, tree expr, gimple *stmt)
 	  Value_Range r1 (type);
 	  r1.set_varying (type);
 	  range_of_expr (r0, TREE_OPERAND (expr, 0), stmt);
-	  op.fold_range (r, type, r0, r1);
+	  if (!op.fold_range (r, type, r0, r1))
+	    r.set_varying (type);
 	}
       else
 	r.set_varying (type);