Remove use_equiv_p in vr-values.cc

Message ID 20221122135801.1945438-3-aldyh@redhat.com
State New
Headers
Series Remove use_equiv_p in vr-values.cc |

Commit Message

Aldy Hernandez Nov. 22, 2022, 1:58 p.m. UTC
  With no equivalences, the use_equiv_p argument in various methods in
simplify_using_ranges is always false.  This means we can remove all
calls to compare_names, along with the function.

OK pending tests?

gcc/ChangeLog:

	* vr-values.cc (simplify_using_ranges::compare_names): Remove.
	(vrp_evaluate_conditional_warnv_with_ops): Remove call to
	compare_names.
	(simplify_using_ranges::vrp_visit_cond_stmt): Remove use_equiv_p
	argument to vrp_evaluate_conditional_warnv_with_ops.
	* vr-values.h (class simplify_using_ranges): Remove
	compare_names.
	Remove use_equiv_p to vrp_evaluate_conditional_warnv_with_ops.
---
 gcc/vr-values.cc | 127 +----------------------------------------------
 gcc/vr-values.h  |   4 +-
 2 files changed, 3 insertions(+), 128 deletions(-)
  

Comments

Richard Biener Nov. 23, 2022, 8:29 p.m. UTC | #1
On Tue, Nov 22, 2022 at 2:58 PM Aldy Hernandez <aldyh@redhat.com> wrote:
>
> With no equivalences, the use_equiv_p argument in various methods in
> simplify_using_ranges is always false.  This means we can remove all
> calls to compare_names, along with the function.
>
> OK pending tests?

OK

> gcc/ChangeLog:
>
>         * vr-values.cc (simplify_using_ranges::compare_names): Remove.
>         (vrp_evaluate_conditional_warnv_with_ops): Remove call to
>         compare_names.
>         (simplify_using_ranges::vrp_visit_cond_stmt): Remove use_equiv_p
>         argument to vrp_evaluate_conditional_warnv_with_ops.
>         * vr-values.h (class simplify_using_ranges): Remove
>         compare_names.
>         Remove use_equiv_p to vrp_evaluate_conditional_warnv_with_ops.
> ---
>  gcc/vr-values.cc | 127 +----------------------------------------------
>  gcc/vr-values.h  |   4 +-
>  2 files changed, 3 insertions(+), 128 deletions(-)
>
> diff --git a/gcc/vr-values.cc b/gcc/vr-values.cc
> index b0dd30260ae..1dbd9e47085 100644
> --- a/gcc/vr-values.cc
> +++ b/gcc/vr-values.cc
> @@ -667,124 +667,6 @@ simplify_using_ranges::compare_name_with_value
>    return retval;
>  }
>
> -/* Given a comparison code COMP and names N1 and N2, compare all the
> -   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 undefined signed overflow in the comparison.  */
> -
> -
> -tree
> -simplify_using_ranges::compare_names (enum tree_code comp, tree n1, tree n2,
> -                                     bool *strict_overflow_p, gimple *s)
> -{
> -  /* ?? These bitmaps are NULL as there are no longer any equivalences
> -     available in the value_range*.  */
> -  bitmap e1 = NULL;
> -  bitmap e2 = NULL;
> -
> -  /* Use the fake bitmaps if e1 or e2 are not available.  */
> -  static bitmap s_e1 = NULL, s_e2 = NULL;
> -  static bitmap_obstack *s_obstack = NULL;
> -  if (s_obstack == NULL)
> -    {
> -      s_obstack = XNEW (bitmap_obstack);
> -      bitmap_obstack_initialize (s_obstack);
> -      s_e1 = BITMAP_ALLOC (s_obstack);
> -      s_e2 = BITMAP_ALLOC (s_obstack);
> -    }
> -  if (e1 == NULL)
> -    e1 = s_e1;
> -  if (e2 == NULL)
> -    e2 = s_e2;
> -
> -  /* Add N1 and N2 to their own set of equivalences to avoid
> -     duplicating the body of the loop just to check N1 and N2
> -     ranges.  */
> -  bitmap_set_bit (e1, SSA_NAME_VERSION (n1));
> -  bitmap_set_bit (e2, SSA_NAME_VERSION (n2));
> -
> -  /* If the equivalence sets have a common intersection, then the two
> -     names can be compared without checking their ranges.  */
> -  if (bitmap_intersect_p (e1, e2))
> -    {
> -      bitmap_clear_bit (e1, SSA_NAME_VERSION (n1));
> -      bitmap_clear_bit (e2, SSA_NAME_VERSION (n2));
> -
> -      return (comp == EQ_EXPR || comp == GE_EXPR || comp == LE_EXPR)
> -            ? boolean_true_node
> -            : boolean_false_node;
> -    }
> -
> -  /* Start at -1.  Set it to 0 if we do a comparison without relying
> -     on overflow, or 1 if all comparisons rely on overflow.  */
> -  int used_strict_overflow = -1;
> -
> -  /* Otherwise, compare all the equivalent ranges.  First, add N1 and
> -     N2 to their own set of equivalences to avoid duplicating the body
> -     of the loop just to check N1 and N2 ranges.  */
> -  bitmap_iterator bi1;
> -  unsigned i1;
> -  EXECUTE_IF_SET_IN_BITMAP (e1, 0, i1, bi1)
> -    {
> -      if (!ssa_name (i1))
> -       continue;
> -
> -      value_range tem_vr1;
> -      const value_range *vr1 = get_vr_for_comparison (i1, &tem_vr1, s);
> -
> -      tree t = NULL_TREE, retval = NULL_TREE;
> -      bitmap_iterator bi2;
> -      unsigned i2;
> -      EXECUTE_IF_SET_IN_BITMAP (e2, 0, i2, bi2)
> -       {
> -         if (!ssa_name (i2))
> -           continue;
> -
> -         bool sop = false;
> -
> -         value_range tem_vr2;
> -         const value_range *vr2 = get_vr_for_comparison (i2, &tem_vr2, s);
> -
> -         t = compare_ranges (comp, vr1, vr2, &sop);
> -         if (t)
> -           {
> -             /* If we get different answers from different members
> -                of the equivalence set this check must be in a dead
> -                code region.  Folding it to a trap representation
> -                would be correct here.  For now just return don't-know.  */
> -             if (retval != NULL && t != retval)
> -               {
> -                 bitmap_clear_bit (e1, SSA_NAME_VERSION (n1));
> -                 bitmap_clear_bit (e2, SSA_NAME_VERSION (n2));
> -                 return NULL_TREE;
> -               }
> -             retval = t;
> -
> -             if (!sop)
> -               used_strict_overflow = 0;
> -             else if (used_strict_overflow < 0)
> -               used_strict_overflow = 1;
> -           }
> -       }
> -
> -      if (retval)
> -       {
> -         bitmap_clear_bit (e1, SSA_NAME_VERSION (n1));
> -         bitmap_clear_bit (e2, SSA_NAME_VERSION (n2));
> -         if (used_strict_overflow > 0)
> -           *strict_overflow_p = true;
> -         return retval;
> -       }
> -    }
> -
> -  /* None of the equivalent ranges are useful in computing this
> -     comparison.  */
> -  bitmap_clear_bit (e1, SSA_NAME_VERSION (n1));
> -  bitmap_clear_bit (e2, SSA_NAME_VERSION (n2));
> -  return NULL_TREE;
> -}
> -
>  /* Helper function for vrp_evaluate_conditional_warnv & other
>     optimizers.  */
>
> @@ -815,7 +697,6 @@ simplify_using_ranges::vrp_evaluate_conditional_warnv_with_ops
>                                                 (gimple *stmt,
>                                                  enum tree_code code,
>                                                  tree op0, tree op1,
> -                                                bool use_equiv_p,
>                                                  bool *strict_overflow_p,
>                                                  bool *only_ranges)
>  {
> @@ -899,11 +780,7 @@ simplify_using_ranges::vrp_evaluate_conditional_warnv_with_ops
>      return ret;
>    if (only_ranges)
>      *only_ranges = false;
> -  /* Do not use compare_names during propagation, it's quadratic.  */
> -  if (TREE_CODE (op0) == SSA_NAME && TREE_CODE (op1) == SSA_NAME
> -      && use_equiv_p)
> -    return compare_names (code, op0, op1, strict_overflow_p, stmt);
> -  else if (TREE_CODE (op0) == SSA_NAME)
> +  if (TREE_CODE (op0) == SSA_NAME)
>      return compare_name_with_value (code, op0, op1, strict_overflow_p, stmt);
>    else if (TREE_CODE (op1) == SSA_NAME)
>      return compare_name_with_value (swap_tree_comparison (code), op1, op0,
> @@ -949,7 +826,7 @@ simplify_using_ranges::vrp_visit_cond_stmt (gcond *stmt, edge *taken_edge_p)
>                                                  gimple_cond_code (stmt),
>                                                  gimple_cond_lhs (stmt),
>                                                  gimple_cond_rhs (stmt),
> -                                                false, &sop, NULL);
> +                                                &sop, NULL);
>    if (val)
>      *taken_edge_p = find_taken_edge (gimple_bb (stmt), val);
>
> diff --git a/gcc/vr-values.h b/gcc/vr-values.h
> index 9804aaf83d1..6ad9fb2b81d 100644
> --- a/gcc/vr-values.h
> +++ b/gcc/vr-values.h
> @@ -37,8 +37,7 @@ public:
>  private:
>    void vrp_visit_cond_stmt (gcond *, edge *);
>    tree vrp_evaluate_conditional_warnv_with_ops (gimple *stmt, enum tree_code,
> -                                               tree, tree, bool,
> -                                               bool *, bool *);
> +                                               tree, tree, bool *, bool *);
>    bool simplify_casted_cond (gcond *);
>    bool simplify_truth_ops_using_ranges (gimple_stmt_iterator *, gimple *);
>    bool simplify_div_or_mod_using_ranges (gimple_stmt_iterator *, gimple *);
> @@ -54,7 +53,6 @@ private:
>    bool two_valued_val_range_p (tree, tree *, tree *, gimple *);
>    bool op_with_boolean_value_range_p (tree, gimple *);
>    tree compare_name_with_value (enum tree_code, tree, tree, bool *, gimple *);
> -  tree compare_names (enum tree_code, tree, tree, bool *, gimple *s);
>    const value_range *get_vr_for_comparison (int, value_range *, gimple *s);
>    tree vrp_evaluate_conditional_warnv_with_ops_using_ranges (enum tree_code,
>                                                              tree, tree,
> --
> 2.38.1
>
  

Patch

diff --git a/gcc/vr-values.cc b/gcc/vr-values.cc
index b0dd30260ae..1dbd9e47085 100644
--- a/gcc/vr-values.cc
+++ b/gcc/vr-values.cc
@@ -667,124 +667,6 @@  simplify_using_ranges::compare_name_with_value
   return retval;
 }
 
-/* Given a comparison code COMP and names N1 and N2, compare all the
-   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 undefined signed overflow in the comparison.  */
-
-
-tree
-simplify_using_ranges::compare_names (enum tree_code comp, tree n1, tree n2,
-				      bool *strict_overflow_p, gimple *s)
-{
-  /* ?? These bitmaps are NULL as there are no longer any equivalences
-     available in the value_range*.  */
-  bitmap e1 = NULL;
-  bitmap e2 = NULL;
-
-  /* Use the fake bitmaps if e1 or e2 are not available.  */
-  static bitmap s_e1 = NULL, s_e2 = NULL;
-  static bitmap_obstack *s_obstack = NULL;
-  if (s_obstack == NULL)
-    {
-      s_obstack = XNEW (bitmap_obstack);
-      bitmap_obstack_initialize (s_obstack);
-      s_e1 = BITMAP_ALLOC (s_obstack);
-      s_e2 = BITMAP_ALLOC (s_obstack);
-    }
-  if (e1 == NULL)
-    e1 = s_e1;
-  if (e2 == NULL)
-    e2 = s_e2;
-
-  /* Add N1 and N2 to their own set of equivalences to avoid
-     duplicating the body of the loop just to check N1 and N2
-     ranges.  */
-  bitmap_set_bit (e1, SSA_NAME_VERSION (n1));
-  bitmap_set_bit (e2, SSA_NAME_VERSION (n2));
-
-  /* If the equivalence sets have a common intersection, then the two
-     names can be compared without checking their ranges.  */
-  if (bitmap_intersect_p (e1, e2))
-    {
-      bitmap_clear_bit (e1, SSA_NAME_VERSION (n1));
-      bitmap_clear_bit (e2, SSA_NAME_VERSION (n2));
-
-      return (comp == EQ_EXPR || comp == GE_EXPR || comp == LE_EXPR)
-	     ? boolean_true_node
-	     : boolean_false_node;
-    }
-
-  /* Start at -1.  Set it to 0 if we do a comparison without relying
-     on overflow, or 1 if all comparisons rely on overflow.  */
-  int used_strict_overflow = -1;
-
-  /* Otherwise, compare all the equivalent ranges.  First, add N1 and
-     N2 to their own set of equivalences to avoid duplicating the body
-     of the loop just to check N1 and N2 ranges.  */
-  bitmap_iterator bi1;
-  unsigned i1;
-  EXECUTE_IF_SET_IN_BITMAP (e1, 0, i1, bi1)
-    {
-      if (!ssa_name (i1))
-	continue;
-
-      value_range tem_vr1;
-      const value_range *vr1 = get_vr_for_comparison (i1, &tem_vr1, s);
-
-      tree t = NULL_TREE, retval = NULL_TREE;
-      bitmap_iterator bi2;
-      unsigned i2;
-      EXECUTE_IF_SET_IN_BITMAP (e2, 0, i2, bi2)
-	{
-	  if (!ssa_name (i2))
-	    continue;
-
-	  bool sop = false;
-
-	  value_range tem_vr2;
-	  const value_range *vr2 = get_vr_for_comparison (i2, &tem_vr2, s);
-
-	  t = compare_ranges (comp, vr1, vr2, &sop);
-	  if (t)
-	    {
-	      /* If we get different answers from different members
-		 of the equivalence set this check must be in a dead
-		 code region.  Folding it to a trap representation
-		 would be correct here.  For now just return don't-know.  */
-	      if (retval != NULL && t != retval)
-		{
-		  bitmap_clear_bit (e1, SSA_NAME_VERSION (n1));
-		  bitmap_clear_bit (e2, SSA_NAME_VERSION (n2));
-		  return NULL_TREE;
-		}
-	      retval = t;
-
-	      if (!sop)
-		used_strict_overflow = 0;
-	      else if (used_strict_overflow < 0)
-		used_strict_overflow = 1;
-	    }
-	}
-
-      if (retval)
-	{
-	  bitmap_clear_bit (e1, SSA_NAME_VERSION (n1));
-	  bitmap_clear_bit (e2, SSA_NAME_VERSION (n2));
-	  if (used_strict_overflow > 0)
-	    *strict_overflow_p = true;
-	  return retval;
-	}
-    }
-
-  /* None of the equivalent ranges are useful in computing this
-     comparison.  */
-  bitmap_clear_bit (e1, SSA_NAME_VERSION (n1));
-  bitmap_clear_bit (e2, SSA_NAME_VERSION (n2));
-  return NULL_TREE;
-}
-
 /* Helper function for vrp_evaluate_conditional_warnv & other
    optimizers.  */
 
@@ -815,7 +697,6 @@  simplify_using_ranges::vrp_evaluate_conditional_warnv_with_ops
 						(gimple *stmt,
 						 enum tree_code code,
 						 tree op0, tree op1,
-						 bool use_equiv_p,
 						 bool *strict_overflow_p,
 						 bool *only_ranges)
 {
@@ -899,11 +780,7 @@  simplify_using_ranges::vrp_evaluate_conditional_warnv_with_ops
     return ret;
   if (only_ranges)
     *only_ranges = false;
-  /* Do not use compare_names during propagation, it's quadratic.  */
-  if (TREE_CODE (op0) == SSA_NAME && TREE_CODE (op1) == SSA_NAME
-      && use_equiv_p)
-    return compare_names (code, op0, op1, strict_overflow_p, stmt);
-  else if (TREE_CODE (op0) == SSA_NAME)
+  if (TREE_CODE (op0) == SSA_NAME)
     return compare_name_with_value (code, op0, op1, strict_overflow_p, stmt);
   else if (TREE_CODE (op1) == SSA_NAME)
     return compare_name_with_value (swap_tree_comparison (code), op1, op0,
@@ -949,7 +826,7 @@  simplify_using_ranges::vrp_visit_cond_stmt (gcond *stmt, edge *taken_edge_p)
 						 gimple_cond_code (stmt),
 						 gimple_cond_lhs (stmt),
 						 gimple_cond_rhs (stmt),
-						 false, &sop, NULL);
+						 &sop, NULL);
   if (val)
     *taken_edge_p = find_taken_edge (gimple_bb (stmt), val);
 
diff --git a/gcc/vr-values.h b/gcc/vr-values.h
index 9804aaf83d1..6ad9fb2b81d 100644
--- a/gcc/vr-values.h
+++ b/gcc/vr-values.h
@@ -37,8 +37,7 @@  public:
 private:
   void vrp_visit_cond_stmt (gcond *, edge *);
   tree vrp_evaluate_conditional_warnv_with_ops (gimple *stmt, enum tree_code,
-						tree, tree, bool,
-						bool *, bool *);
+						tree, tree, bool *, bool *);
   bool simplify_casted_cond (gcond *);
   bool simplify_truth_ops_using_ranges (gimple_stmt_iterator *, gimple *);
   bool simplify_div_or_mod_using_ranges (gimple_stmt_iterator *, gimple *);
@@ -54,7 +53,6 @@  private:
   bool two_valued_val_range_p (tree, tree *, tree *, gimple *);
   bool op_with_boolean_value_range_p (tree, gimple *);
   tree compare_name_with_value (enum tree_code, tree, tree, bool *, gimple *);
-  tree compare_names (enum tree_code, tree, tree, bool *, gimple *s);
   const value_range *get_vr_for_comparison (int, value_range *, gimple *s);
   tree vrp_evaluate_conditional_warnv_with_ops_using_ranges (enum tree_code,
 							     tree, tree,