Add statement context to get_value_range.

This is in line with the statement context that we have for get_value()
in the substitute_and_fold_engine class.

gcc/ChangeLog:

	* vr-values.c (vr_values::get_value_range): Add stmt param.
	(vr_values::extract_range_from_comparison): Same.
	(vr_values::extract_range_from_assignment): Pass stmt to
	extract_range_from_comparison.
	(vr_values::adjust_range_with_scev): Pass stmt to get_value_range.
	(simplify_using_ranges::vrp_evaluate_conditional): Add stmt param.
	Pass stmt to get_value_range.
	(simplify_using_ranges::vrp_visit_cond_stmt): Pass stmt to
	get_value_range.
	(simplify_using_ranges::simplify_abs_using_ranges): Same.
	(simplify_using_ranges::simplify_div_or_mod_using_ranges): Same.
	(simplify_using_ranges::simplify_bit_ops_using_ranges): Same.
	(simplify_using_ranges::simplify_cond_using_ranges_1): Same.
	(simplify_using_ranges::simplify_switch_using_ranges): Same.
	(simplify_using_ranges::simplify_float_conversion_using_ranges): Same.
	* vr-values.h (class vr_values): Add stmt arg to
	vrp_evaluate_conditional_warnv_with_ops.
	Add stmt arg to extract_range_from_comparison and get_value_range.
	(simplify_using_ranges::get_value_range): Add stmt arg.

diff --git a/gcc/vr-values.c b/gcc/vr-values.c
index 511342f2f132124e260d03e3ff4301c398f98bc7..fe51a6faeb81882df0fdc4cb7aa2c5230487376c 100644 (file)
--- a/gcc/vr-values.c
+++ b/gcc/vr-values.c
@@ -147,7 +147,8 @@ vr_values::get_lattice_entry (const_tree var)
    return NULL.  Otherwise create an empty range if none existed for VAR.  */
 
 const value_range_equiv *
-vr_values::get_value_range (const_tree var)
+vr_values::get_value_range (const_tree var,
+                           gimple *stmt ATTRIBUTE_UNUSED)
 {
   /* If we have no recorded ranges, then return NULL.  */
   if (!vr_value)
@@ -972,12 +973,15 @@ vr_values::extract_range_from_cond_expr (value_range_equiv *vr, gassign *stmt)
 
 void
 vr_values::extract_range_from_comparison (value_range_equiv *vr,
-                                         enum tree_code code,
-                                         tree type, tree op0, tree op1)
+                                         gimple *stmt)
 {
+  enum tree_code code = gimple_assign_rhs_code (stmt);
+  tree type = gimple_expr_type (stmt);
+  tree op0 = gimple_assign_rhs1 (stmt);
+  tree op1 = gimple_assign_rhs2 (stmt);
   bool sop;
   tree val
-    = simplifier.vrp_evaluate_conditional_warnv_with_ops (code, op0, op1,
+    = simplifier.vrp_evaluate_conditional_warnv_with_ops (stmt, code, op0, op1,
                                                          false, &sop, NULL);
   if (val)
     {
@@ -1472,10 +1476,7 @@ vr_values::extract_range_from_assignment (value_range_equiv *vr, gassign *stmt)
   else if (code == COND_EXPR)
     extract_range_from_cond_expr (vr, stmt);
   else if (TREE_CODE_CLASS (code) == tcc_comparison)
-    extract_range_from_comparison (vr, gimple_assign_rhs_code (stmt),
-                                  gimple_expr_type (stmt),
-                                  gimple_assign_rhs1 (stmt),
-                                  gimple_assign_rhs2 (stmt));
+    extract_range_from_comparison (vr, stmt);
   else if (get_gimple_rhs_class (code) == GIMPLE_SINGLE_RHS
           && is_gimple_min_invariant (gimple_assign_rhs1 (stmt)))
     vr->set (gimple_assign_rhs1 (stmt));
@@ -1805,7 +1806,7 @@ vr_values::adjust_range_with_scev (value_range_equiv *vr, class loop *loop,
   if (TREE_CODE (step) == INTEGER_CST
       && is_gimple_val (init)
       && (TREE_CODE (init) != SSA_NAME
-         || get_value_range (init)->kind () == VR_RANGE))
+         || get_value_range (init, stmt)->kind () == VR_RANGE))
     {
       widest_int nit;
 
@@ -1838,7 +1839,7 @@ vr_values::adjust_range_with_scev (value_range_equiv *vr, class loop *loop,
                  value_range initvr;
 
                  if (TREE_CODE (init) == SSA_NAME)
-                   initvr = *(get_value_range (init));
+                   initvr = *(get_value_range (init, stmt));
                  else if (is_gimple_min_invariant (init))
                    initvr.set (init);
                  else
@@ -2326,7 +2327,8 @@ simplify_using_ranges::vrp_evaluate_conditional_warnv_with_ops_using_ranges
 
 tree
 simplify_using_ranges::vrp_evaluate_conditional_warnv_with_ops
-                                               (enum tree_code code,
+                                               (gimple *stmt,
+                                                enum tree_code code,
                                                 tree op0, tree op1,
                                                 bool use_equiv_p,
                                                 bool *strict_overflow_p,
@@ -2387,7 +2389,7 @@ simplify_using_ranges::vrp_evaluate_conditional_warnv_with_ops
            }
          else
            gcc_unreachable ();
-         const value_range_equiv *vr0 = get_value_range (op0);
+         const value_range_equiv *vr0 = get_value_range (op0, stmt);
          /* If vro, the range for OP0 to pass the overflow test, has
             no intersection with *vr0, OP0's known range, then the
             overflow test can't pass, so return the node for false.
@@ -2449,8 +2451,8 @@ simplify_using_ranges::vrp_evaluate_conditional (tree_code code, tree op0,
     return NULL_TREE;
 
   sop = false;
-  ret = vrp_evaluate_conditional_warnv_with_ops (code, op0, op1, true, &sop,
-                                                &only_ranges);
+  ret = vrp_evaluate_conditional_warnv_with_ops (stmt, code, op0, op1, true,
+                                                &sop, &only_ranges);
 
   if (ret && sop)
     {
@@ -2493,7 +2495,7 @@ simplify_using_ranges::vrp_evaluate_conditional (tree_code code, tree op0,
         always fold regardless of the value of OP0.  If -Wtype-limits
         was specified, emit a warning.  */
       tree type = TREE_TYPE (op0);
-      const value_range_equiv *vr0 = get_value_range (op0);
+      const value_range_equiv *vr0 = get_value_range (op0, stmt);
 
       if (vr0->varying_p ()
          && INTEGRAL_TYPE_P (type)
@@ -2544,7 +2546,7 @@ simplify_using_ranges::vrp_visit_cond_stmt (gcond *stmt, edge *taken_edge_p)
          fprintf (dump_file, "\t");
          print_generic_expr (dump_file, use);
          fprintf (dump_file, ": ");
-         dump_value_range (dump_file, get_value_range (use));
+         dump_value_range (dump_file, get_value_range (use, stmt));
        }
 
       fprintf (dump_file, "\n");
@@ -2594,7 +2596,8 @@ simplify_using_ranges::vrp_visit_cond_stmt (gcond *stmt, edge *taken_edge_p)
      4 more predicates folded in SPEC.  */
 
   bool sop;
-  val = vrp_evaluate_conditional_warnv_with_ops (gimple_cond_code (stmt),
+  val = vrp_evaluate_conditional_warnv_with_ops (stmt,
+                                                gimple_cond_code (stmt),
                                                 gimple_cond_lhs (stmt),
                                                 gimple_cond_rhs (stmt),
                                                 false, &sop, NULL);
@@ -3119,7 +3122,7 @@ simplify_using_ranges::simplify_div_or_mod_using_ranges
     }
   else
     {
-      vr = get_value_range (op0);
+      vr = get_value_range (op0, stmt);
       if (range_int_cst_p (vr))
        {
          op0min = vr->min ();
@@ -3130,7 +3133,7 @@ simplify_using_ranges::simplify_div_or_mod_using_ranges
   if (rhs_code == TRUNC_MOD_EXPR
       && TREE_CODE (op1) == SSA_NAME)
     {
-      const value_range_equiv *vr1 = get_value_range (op1);
+      const value_range_equiv *vr1 = get_value_range (op1, stmt);
       if (range_int_cst_p (vr1))
        op1min = vr1->min ();
     }
@@ -3279,7 +3282,7 @@ simplify_using_ranges::simplify_abs_using_ranges (gimple_stmt_iterator *gsi,
                                                  gimple *stmt)
 {
   tree op = gimple_assign_rhs1 (stmt);
-  const value_range *vr = get_value_range (op);
+  const value_range *vr = get_value_range (op, stmt);
 
   if (vr)
     {
@@ -3369,14 +3372,14 @@ simplify_using_ranges::simplify_bit_ops_using_ranges
   wide_int mask;
 
   if (TREE_CODE (op0) == SSA_NAME)
-    vr0 = *(get_value_range (op0));
+    vr0 = *(get_value_range (op0, stmt));
   else if (is_gimple_min_invariant (op0))
     vr0.set (op0);
   else
     return false;
 
   if (TREE_CODE (op1) == SSA_NAME)
-    vr1 = *(get_value_range (op1));
+    vr1 = *(get_value_range (op1, stmt));
   else if (is_gimple_min_invariant (op1))
     vr1.set (op1);
   else
@@ -3595,7 +3598,7 @@ simplify_using_ranges::simplify_cond_using_ranges_1 (gcond *stmt)
       && INTEGRAL_TYPE_P (TREE_TYPE (op0))
       && is_gimple_min_invariant (op1))
     {
-      const value_range *vr = get_value_range (op0);
+      const value_range *vr = get_value_range (op0, stmt);
 
       /* If we have range information for OP0, then we might be
         able to simplify this conditional. */
@@ -3739,7 +3742,7 @@ simplify_using_ranges::simplify_switch_using_ranges (gswitch *stmt)
 
   if (TREE_CODE (op) == SSA_NAME)
     {
-      vr = get_value_range (op);
+      vr = get_value_range (op, stmt);
 
       /* We can only handle integer ranges.  */
       if (vr->varying_p ()
@@ -4032,7 +4035,7 @@ simplify_using_ranges::simplify_float_conversion_using_ranges
                                         gimple *stmt)
 {
   tree rhs1 = gimple_assign_rhs1 (stmt);
-  const value_range *vr = get_value_range (rhs1);
+  const value_range *vr = get_value_range (rhs1, stmt);
   scalar_float_mode fltmode
     = SCALAR_FLOAT_TYPE_MODE (TREE_TYPE (gimple_assign_lhs (stmt)));
   scalar_int_mode mode;

diff --git a/gcc/vr-values.h b/gcc/vr-values.h
index 62a20218c6d16a0a787b06652e3653d63813321c..330b4605e39b0b95b57d42f6239cd64ca1991522 100644 (file)
--- a/gcc/vr-values.h
+++ b/gcc/vr-values.h
@@ -38,12 +38,13 @@ public:
   // ?? These should be cleaned, merged, and made private.
   tree vrp_evaluate_conditional (tree_code, tree, tree, gimple *);
   void vrp_visit_cond_stmt (gcond *, edge *);
-  tree vrp_evaluate_conditional_warnv_with_ops (enum tree_code,
+  tree vrp_evaluate_conditional_warnv_with_ops (gimple *stmt, enum tree_code,
                                                tree, tree, bool,
                                                bool *, bool *);
 
 private:
-  const value_range_equiv *get_value_range (const_tree op);
+  const value_range_equiv *get_value_range (const_tree op,
+                                           gimple *stmt = NULL);
   bool simplify_truth_ops_using_ranges (gimple_stmt_iterator *, gimple *);
   bool simplify_div_or_mod_using_ranges (gimple_stmt_iterator *, gimple *);
   bool simplify_abs_using_ranges (gimple_stmt_iterator *, gimple *);
@@ -101,7 +102,7 @@ class vr_values
   vr_values (void);
   ~vr_values (void);
 
-  const value_range_equiv *get_value_range (const_tree);
+  const value_range_equiv *get_value_range (const_tree, gimple * = NULL);
   void set_vr_value (tree, value_range_equiv *);
   value_range_equiv *swap_vr_value (tree, value_range_equiv *);
 
@@ -140,8 +141,7 @@ class vr_values
   void extract_range_from_unary_expr (value_range_equiv *, enum tree_code,
                                      tree, tree);
   void extract_range_from_cond_expr (value_range_equiv *, gassign *);
-  void extract_range_from_comparison (value_range_equiv *, enum tree_code,
-                                     tree, tree, tree);
+  void extract_range_from_comparison (value_range_equiv *, gimple *);
   void vrp_visit_assignment_or_call (gimple*, tree *, value_range_equiv *);
   void vrp_visit_switch_stmt (gswitch *, edge *);
 
@@ -167,9 +167,9 @@ class vr_values
 };
 
 inline const value_range_equiv *
-simplify_using_ranges::get_value_range (const_tree op)
+simplify_using_ranges::get_value_range (const_tree op, gimple *stmt)
 {
-  return store->get_value_range (op);
+  return store->get_value_range (op, stmt);
 }
 
 extern tree get_output_for_vrp (gimple *);