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.

diff --git a/gcc/gimple-range-fold.cc b/gcc/gimple-range-fold.cc
index addf3e7f2549fba8ed314b50cf7f91315bd086b2..42408254c351ecb04b8679b931afc14523ff2e4f 100644 (file)
--- 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 ff9327f6deb2bb85abbd3853dca9c666699e7a37..91bfb619d6695dc072b70d8cc8a728ad01ec3409 100644 (file)
--- 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 c3030a1b13054ce527f4102de633c642942bba4d..93482e5d1027778a53fabf97f1f5e5f6fa8c953e 100644 (file)
--- 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 0bdd670982b50709b77b0bf02c6a089e615725c7..296784be31d133037b3cb7e0b9933c9fb23bd3fe 100644 (file)
--- 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);