The base class for ranges is currently value_range_base, which is rather long and cumbersome.

The base class for ranges is currently value_range_base, which is
rather long and cumbersome.  It also occurs more often than the derived
class of value_range.  To avoid confusion, and save typing, this
patch does a global rename from value_range to value_range_equiv,
and from value_range_base to value_range.

This way, the base class is simply value_range, and the derived
class is value_range_equiv which explicitly states what it does.

From-SVN: r277847

1 files changed, 65 insertions, 65 deletions

diff --git a/gcc/tree-vrp.h b/gcc/tree-vrp.h
index 0bf33ca..ff01c2a 100644
--- a/gcc/tree-vrp.h
+++ b/gcc/tree-vrp.h
@@ -37,17 +37,17 @@ enum value_range_kind
 
 /* Range of values that can be associated with an SSA_NAME after VRP
    has executed.  */
-class GTY((for_user)) value_range_base
+class GTY((for_user)) value_range
 {
   friend void range_tests ();
 public:
-  value_range_base ();
-  value_range_base (value_range_kind, tree, tree);
-  value_range_base (tree, tree);
-  value_range_base (value_range_kind,
-		    tree type, const wide_int &, const wide_int &);
-  value_range_base (tree type, const wide_int &, const wide_int &);
-  value_range_base (tree type);
+  value_range ();
+  value_range (value_range_kind, tree, tree);
+  value_range (tree, tree);
+  value_range (value_range_kind,
+	       tree type, const wide_int &, const wide_int &);
+  value_range (tree type, const wide_int &, const wide_int &);
+  value_range (tree type);
 
   void set (value_range_kind, tree, tree);
   void set (tree);
@@ -66,14 +66,14 @@ public:
   void set_varying (tree type);
   void set_undefined ();
 
-  void union_ (const value_range_base *);
-  void intersect (const value_range_base *);
-  void union_ (const value_range_base &);
-  void intersect (const value_range_base &);
+  void union_ (const value_range *);
+  void intersect (const value_range *);
+  void union_ (const value_range &);
+  void intersect (const value_range &);
 
-  bool operator== (const value_range_base &) const;
-  bool operator!= (const value_range_base &) const /* = delete */;
-  bool equal_p (const value_range_base &) const;
+  bool operator== (const value_range &) const;
+  bool operator!= (const value_range &) const /* = delete */;
+  bool equal_p (const value_range &) const;
 
   /* Misc methods.  */
   tree type () const;
@@ -85,8 +85,8 @@ public:
   void dump () const;
 
   static bool supports_type_p (tree);
-  value_range_base normalize_symbolics () const;
-  value_range_base normalize_addresses () const;
+  value_range normalize_symbolics () const;
+  value_range normalize_addresses () const;
 
   static const unsigned int m_max_pairs = 2;
   bool contains_p (tree) const;
@@ -98,46 +98,45 @@ public:
 
 protected:
   void check ();
-  static value_range_base union_helper (const value_range_base *,
-					const value_range_base *);
-  static value_range_base intersect_helper (const value_range_base *,
-					    const value_range_base *);
+  static value_range union_helper (const value_range *, const value_range *);
+  static value_range intersect_helper (const value_range *,
+				       const value_range *);
 
   enum value_range_kind m_kind;
 
   tree m_min;
   tree m_max;
 
-  friend void gt_ggc_mx_value_range_base (void *);
-  friend void gt_pch_p_16value_range_base (void *, void *,
-					   gt_pointer_operator, void *);
-  friend void gt_pch_nx_value_range_base (void *);
-  friend void gt_ggc_mx (value_range_base &);
-  friend void gt_ggc_mx (value_range_base *&);
-  friend void gt_pch_nx (value_range_base &);
-  friend void gt_pch_nx (value_range_base *, gt_pointer_operator, void *);
+  friend void gt_ggc_mx_value_range (void *);
+  friend void gt_pch_p_11value_range (void *, void *,
+				      gt_pointer_operator, void *);
+  friend void gt_pch_nx_value_range (void *);
+  friend void gt_ggc_mx (value_range &);
+  friend void gt_ggc_mx (value_range *&);
+  friend void gt_pch_nx (value_range &);
+  friend void gt_pch_nx (value_range *, gt_pointer_operator, void *);
 
 private:
   int value_inside_range (tree) const;
 };
 
-/* Note value_range cannot currently be used with GC memory, only
-   value_range_base is fully set up for this.  */
-class GTY((user)) value_range : public value_range_base
+/* Note value_range_equiv cannot currently be used with GC memory,
+   only value_range is fully set up for this.  */
+class GTY((user)) value_range_equiv : public value_range
 {
  public:
-  value_range ();
-  value_range (const value_range_base &);
+  value_range_equiv ();
+  value_range_equiv (const value_range &);
   /* Deep-copies equiv bitmap argument.  */
-  value_range (value_range_kind, tree, tree, bitmap = NULL);
+  value_range_equiv (value_range_kind, tree, tree, bitmap = NULL);
 
   /* Shallow-copies equiv bitmap.  */
-  value_range (const value_range &) /* = delete */;
+  value_range_equiv (const value_range_equiv &) /* = delete */;
   /* Shallow-copies equiv bitmap.  */
-  value_range& operator=(const value_range&) /* = delete */;
+  value_range_equiv& operator=(const value_range_equiv &) /* = delete */;
 
   /* Move equiv bitmap from source range.  */
-  void move (value_range *);
+  void move (value_range_equiv *);
 
   /* Leaves equiv bitmap alone.  */
   void update (value_range_kind, tree, tree);
@@ -145,11 +144,11 @@ class GTY((user)) value_range : public value_range_base
   void set (value_range_kind, tree, tree, bitmap = NULL);
   void set (tree);
 
-  bool operator== (const value_range &) const /* = delete */;
-  bool operator!= (const value_range &) const /* = delete */;
-  void intersect (const value_range *);
-  void union_ (const value_range *);
-  bool equal_p (const value_range &, bool ignore_equivs) const;
+  bool operator== (const value_range_equiv &) const /* = delete */;
+  bool operator!= (const value_range_equiv &) const /* = delete */;
+  void intersect (const value_range_equiv *);
+  void union_ (const value_range_equiv *);
+  bool equal_p (const value_range_equiv &, bool ignore_equivs) const;
 
   /* Types of value ranges.  */
   void set_undefined ();
@@ -158,10 +157,11 @@ class GTY((user)) value_range : public value_range_base
   /* Equivalence bitmap methods.  */
   bitmap equiv () const;
   void equiv_clear ();
-  void equiv_add (const_tree, const value_range *, bitmap_obstack * = NULL);
+  void equiv_add (const_tree, const value_range_equiv *,
+		  bitmap_obstack * = NULL);
 
   /* Misc methods.  */
-  void deep_copy (const value_range *);
+  void deep_copy (const value_range_equiv *);
   void dump (FILE *) const;
   void dump () const;
 
@@ -176,15 +176,15 @@ class GTY((user)) value_range : public value_range_base
 };
 
 inline
-value_range_base::value_range_base ()
+value_range::value_range ()
 {
   m_kind = VR_UNDEFINED;
   m_min = m_max = NULL;
 }
 
 inline
-value_range::value_range ()
-  : value_range_base ()
+value_range_equiv::value_range_equiv ()
+  : value_range ()
 {
   m_equiv = NULL;
 }
@@ -192,13 +192,13 @@ value_range::value_range ()
 /* Return the kind of this range.  */
 
 inline value_range_kind
-value_range_base::kind () const
+value_range::kind () const
 {
   return m_kind;
 }
 
 inline bitmap
-value_range::equiv () const
+value_range_equiv::equiv () const
 {
   return m_equiv;
 }
@@ -206,7 +206,7 @@ value_range::equiv () const
 /* Return the lower bound.  */
 
 inline tree
-value_range_base::min () const
+value_range::min () const
 {
   return m_min;
 }
@@ -214,7 +214,7 @@ value_range_base::min () const
 /* Return the upper bound.  */
 
 inline tree
-value_range_base::max () const
+value_range::max () const
 {
   return m_max;
 }
@@ -222,7 +222,7 @@ value_range_base::max () const
 /* Return TRUE if range spans the entire possible domain.  */
 
 inline bool
-value_range_base::varying_p () const
+value_range::varying_p () const
 {
   return m_kind == VR_VARYING;
 }
@@ -230,7 +230,7 @@ value_range_base::varying_p () const
 /* Return TRUE if range is undefined (essentially the empty set).  */
 
 inline bool
-value_range_base::undefined_p () const
+value_range::undefined_p () const
 {
   return m_kind == VR_UNDEFINED;
 }
@@ -238,15 +238,15 @@ value_range_base::undefined_p () const
 /* Return TRUE if range is the constant zero.  */
 
 inline bool
-value_range_base::zero_p () const
+value_range::zero_p () const
 {
   return (m_kind == VR_RANGE
 	  && integer_zerop (m_min)
 	  && integer_zerop (m_max));
 }
 
+extern void dump_value_range (FILE *, const value_range_equiv *);
 extern void dump_value_range (FILE *, const value_range *);
-extern void dump_value_range (FILE *, const value_range_base *);
 
 struct assert_info
 {
@@ -267,7 +267,7 @@ struct assert_info
 // Otherwise return FALSE.
 
 inline bool
-value_range_base::supports_type_p (tree type)
+value_range::supports_type_p (tree type)
 {
   if (type && (INTEGRAL_TYPE_P (type) || POINTER_TYPE_P (type)))
     return type;
@@ -279,7 +279,7 @@ extern void register_edge_assert_for (tree, edge, enum tree_code,
 extern bool stmt_interesting_for_vrp (gimple *);
 extern bool infer_value_range (gimple *, tree, tree_code *, tree *);
 
-extern bool range_int_cst_p (const value_range_base *);
+extern bool range_int_cst_p (const value_range *);
 
 extern int compare_values (tree, tree);
 extern int compare_values_warnv (tree, tree, bool *);
@@ -290,11 +290,11 @@ extern bool vrp_val_is_max (const_tree);
 extern tree vrp_val_min (const_tree);
 extern tree vrp_val_max (const_tree);
 
-void range_fold_unary_expr (value_range_base *, enum tree_code, tree type,
-			    const value_range_base *, tree op0_type);
-void range_fold_binary_expr (value_range_base *, enum tree_code, tree type,
-			     const value_range_base *,
-			     const value_range_base *);
+void range_fold_unary_expr (value_range *, enum tree_code, tree type,
+			    const value_range *, tree op0_type);
+void range_fold_binary_expr (value_range *, enum tree_code, tree type,
+			     const value_range *,
+			     const value_range *);
 
 extern bool vrp_operand_equal_p (const_tree, const_tree);
 extern enum value_range_kind intersect_range_with_nonzero_bits
@@ -310,7 +310,7 @@ extern value_range_kind determine_value_range (tree, wide_int *, wide_int *);
 /* Return TRUE if range is nonzero.  */
 
 inline bool
-value_range_base::nonzero_p () const
+value_range::nonzero_p () const
 {
   if (m_kind == VR_ANTI_RANGE
       && !TYPE_UNSIGNED (type ())
@@ -327,7 +327,7 @@ value_range_base::nonzero_p () const
 /* Return TRUE if *VR includes the value zero.  */
 
 inline bool
-range_includes_zero_p (const value_range_base *vr)
+range_includes_zero_p (const value_range *vr)
 {
   if (vr->undefined_p ())
     return false;