[committed] change normalize_{addresses,symbolics} to work in place
diff mbox series

Message ID cbc047aa-d742-6e34-4cfd-29f3ea01c120@redhat.com
State New
Headers show
Series
  • [committed] change normalize_{addresses,symbolics} to work in place
Related show

Commit Message

Aldy Hernandez Nov. 14, 2019, 7 a.m. UTC
As per Andrew's change returning results by reference instead of value here:

https://gcc.gnu.org/ml/gcc-patches/2019-11/msg00645.html

...attached are the analogous changes to normalize_address and 
normalize_symbolics.

Tested on x86-64 Linux.

Committed as obvious.

Aldy

Patch
diff mbox series

commit 895d6d518988221d57ca858cdfd5d3304b7790f7
Author: Aldy Hernandez <aldyh@redhat.com>
Date:   Wed Nov 13 21:43:33 2019 +0100

    Make normalize_addresses and normalize_symbolics work on THIS, instead
    of returning by value.

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index b51665e28cb..8b4c198ab1d 100644
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,18 @@ 
+2019-11-14  Aldy Hernandez  <aldyh@redhat.com>
+
+	* tree-vrp.c (range_fold_binary_symbolics_p): Adapt for
+	normalize_symbolics and normalize_addresses working in place.
+	(range_fold_unary_symbolics_p): Same.
+	(range_fold_unary_symbolics_p): Same.
+	* value-range.cc (num_pairs): Same.
+	(lower_bound): Same.
+	(upper_bound): Same.
+	(contains_p): Same.
+	(normalize_addresses): Same.
+	(normalize_symbolics): Same.
+	* value-range.h (normalize_symbolics): Same.
+	(normalize_addresses): Same.
+
 2019-11-13  Aldy Hernandez  <aldyh@redhat.com>
 
 	* Makefile.in (OBJS): Add value-range.o.
diff --git a/gcc/tree-vrp.c b/gcc/tree-vrp.c
index c47c65bd294..ff66bed4b03 100644
--- a/gcc/tree-vrp.c
+++ b/gcc/tree-vrp.c
@@ -1182,8 +1182,10 @@  range_fold_binary_symbolics_p (value_range *vr,
 	  return true;
 	}
       const range_operator *op = get_range_op_handler (vr, code, expr_type);
-      op->fold_range (*vr, expr_type, vr0->normalize_symbolics (),
-		      vr1->normalize_symbolics ());
+      value_range vr0_cst (*vr0), vr1_cst (*vr1);
+      vr0_cst.normalize_symbolics ();
+      vr1_cst.normalize_symbolics ();
+      op->fold_range (*vr, expr_type, vr0_cst, vr1_cst);
       return true;
     }
   return false;
@@ -1217,8 +1219,9 @@  range_fold_unary_symbolics_p (value_range *vr,
 	  return true;
 	}
       const range_operator *op = get_range_op_handler (vr, code, expr_type);
-      op->fold_range (*vr, expr_type, vr0->normalize_symbolics (),
-		      value_range (expr_type));
+      value_range vr0_cst (*vr0);
+      vr0_cst.normalize_symbolics ();
+      op->fold_range (*vr, expr_type, vr0_cst, value_range (expr_type));
       return true;
     }
   return false;
@@ -1245,8 +1248,9 @@  range_fold_binary_expr (value_range *vr,
   if (range_fold_binary_symbolics_p (vr, code, expr_type, &vr0, &vr1))
     return;
 
-  op->fold_range (*vr, expr_type, vr0.normalize_addresses (),
-		  vr1.normalize_addresses ());
+  vr0.normalize_addresses ();
+  vr1.normalize_addresses ();
+  op->fold_range (*vr, expr_type, vr0, vr1);
 }
 
 /* Perform a unary operation on a range.  */
@@ -1267,8 +1271,9 @@  range_fold_unary_expr (value_range *vr,
   if (range_fold_unary_symbolics_p (vr, code, expr_type, vr0))
     return;
 
-  op->fold_range (*vr, expr_type, vr0->normalize_addresses (),
-		  value_range (expr_type));
+  value_range vr0_cst (*vr0);
+  vr0_cst.normalize_addresses ();
+  op->fold_range (*vr, expr_type, vr0_cst, value_range (expr_type));
 }
 
 /* Given a COND_EXPR COND of the form 'V OP W', and an SSA name V,
diff --git a/gcc/value-range.cc b/gcc/value-range.cc
index 3d926005743..c4c3416e6fc 100644
--- a/gcc/value-range.cc
+++ b/gcc/value-range.cc
@@ -305,7 +305,11 @@  value_range::num_pairs () const
   if (varying_p ())
     return 1;
   if (symbolic_p ())
-    return normalize_symbolics ().num_pairs ();
+    {
+      value_range numeric_range (*this);
+      numeric_range.normalize_symbolics ();
+      return numeric_range.num_pairs ();
+    }
   if (m_kind == VR_ANTI_RANGE)
     {
       // ~[MIN, X] has one sub-range of [X+1, MAX], and
@@ -324,7 +328,11 @@  wide_int
 value_range::lower_bound (unsigned pair) const
 {
   if (symbolic_p ())
-    return normalize_symbolics ().lower_bound (pair);
+    {
+      value_range numeric_range (*this);
+      numeric_range.normalize_symbolics ();
+      return numeric_range.lower_bound (pair);
+    }
 
   gcc_checking_assert (!undefined_p ());
   gcc_checking_assert (pair + 1 <= num_pairs ());
@@ -349,7 +357,11 @@  wide_int
 value_range::upper_bound (unsigned pair) const
 {
   if (symbolic_p ())
-    return normalize_symbolics ().upper_bound (pair);
+    {
+      value_range numeric_range (*this);
+      numeric_range.normalize_symbolics ();
+      return numeric_range.upper_bound (pair);
+    }
 
   gcc_checking_assert (!undefined_p ());
   gcc_checking_assert (pair + 1 <= num_pairs ());
@@ -505,57 +517,69 @@  value_range::contains_p (tree cst) const
 {
   gcc_checking_assert (TREE_CODE (cst) == INTEGER_CST);
   if (symbolic_p ())
-    return normalize_symbolics ().contains_p (cst);
+    {
+      value_range numeric_range (*this);
+      numeric_range.normalize_symbolics ();
+      return numeric_range.contains_p (cst);
+    }
   return value_inside_range (cst) == 1;
 }
 
 /* Normalize addresses into constants.  */
 
-value_range
-value_range::normalize_addresses () const
+void
+value_range::normalize_addresses ()
 {
   if (undefined_p ())
-    return *this;
+    return;
 
   if (!POINTER_TYPE_P (type ()) || range_has_numeric_bounds_p (this))
-    return *this;
+    return;
 
   if (!range_includes_zero_p (this))
     {
       gcc_checking_assert (TREE_CODE (m_min) == ADDR_EXPR
 			   || TREE_CODE (m_max) == ADDR_EXPR);
-      return range_nonzero (type ());
+      set_nonzero (type ());
+      return;
     }
-  return value_range (type ());
+  set_varying (type ());
 }
 
 /* Normalize symbolics and addresses into constants.  */
 
-value_range
-value_range::normalize_symbolics () const
+void
+value_range::normalize_symbolics ()
 {
   if (varying_p () || undefined_p ())
-    return *this;
+    return;
+
   tree ttype = type ();
   bool min_symbolic = !is_gimple_min_invariant (min ());
   bool max_symbolic = !is_gimple_min_invariant (max ());
   if (!min_symbolic && !max_symbolic)
-    return normalize_addresses ();
+    {
+      normalize_addresses ();
+      return;
+    }
 
   // [SYM, SYM] -> VARYING
   if (min_symbolic && max_symbolic)
     {
-      value_range var;
-      var.set_varying (ttype);
-      return var;
+      set_varying (ttype);
+      return;
     }
   if (kind () == VR_RANGE)
     {
       // [SYM, NUM] -> [-MIN, NUM]
       if (min_symbolic)
-	return value_range (vrp_val_min (ttype), max ());
+	{
+	  set (vrp_val_min (ttype), max ());
+	  return;
+	}
       // [NUM, SYM] -> [NUM, +MAX]
-      return value_range (min (), vrp_val_max (ttype));
+      set (min (), vrp_val_max (ttype));
+      return;
     }
   gcc_checking_assert (kind () == VR_ANTI_RANGE);
   // ~[SYM, NUM] -> [NUM + 1, +MAX]
@@ -564,21 +588,20 @@  value_range::normalize_symbolics () const
       if (!vrp_val_is_max (max ()))
 	{
 	  tree n = wide_int_to_tree (ttype, wi::to_wide (max ()) + 1);
-	  return value_range (n, vrp_val_max (ttype));
+	  set (n, vrp_val_max (ttype));
+	  return;
 	}
-      value_range var;
-      var.set_varying (ttype);
-      return var;
+      set_varying (ttype);
+      return;
     }
   // ~[NUM, SYM] -> [-MIN, NUM - 1]
   if (!vrp_val_is_min (min ()))
     {
       tree n = wide_int_to_tree (ttype, wi::to_wide (min ()) - 1);
-      return value_range (vrp_val_min (ttype), n);
+      set (vrp_val_min (ttype), n);
+      return;
     }
-  value_range var;
-  var.set_varying (ttype);
-  return var;
+  set_varying (ttype);
 }
 
 /* Intersect the two value-ranges { *VR0TYPE, *VR0MIN, *VR0MAX } and
diff --git a/gcc/value-range.h b/gcc/value-range.h
index 8a88e9a6e8c..23b05b4be91 100644
--- a/gcc/value-range.h
+++ b/gcc/value-range.h
@@ -83,8 +83,8 @@  public:
   void dump () const;
 
   static bool supports_type_p (tree);
-  value_range normalize_symbolics () const;
-  value_range normalize_addresses () const;
+  void normalize_symbolics ();
+  void normalize_addresses ();
 
   static const unsigned int m_max_pairs = 2;
   bool contains_p (tree) const;