Implement vrange::supports_type_p.

[I have conservatively assumed that both the loop-ch and loop-unswitch
passes, which also use the ranger, only support integers and pointers.
If the goal is to handle other types as well, irange::supports_p()
should be Value_Range::supports_type_p(), and any uses of
int_range_max should be converted to Value_Range.  I can help in the
conversion if you'd like.]

As discussed, this patch disambiguates the use of supports_type_p
throughout, as what ranger supports is a totally different question
than what a given range variant (irange, frange, etc) supports.

Unfortunately we need both a static method and a virtual method, and
they can't be named the same.  The uses are documented in the vrange
class:

+// To query what types ranger and the entire ecosystem can support,
+// use Value_Range::supports_type_p(tree type).  This is a static
+// method available independently of any vrange object.
+//
+// To query what a given vrange variant can support, use:
+//    irange::supports_p ()
+//    frange::supports_p ()
+//    etc
+//
+// To query what a range object can support, use:
+//    void foo (vrange &v, irange &i, frange &f)
+//    {
+//     if (v.supports_type_p (type)) ...
+//     if (i.supports_type_p (type)) ...
+//     if (f.supports_type_p (type)) ...
+//    }

The value_range_equiv::supports_p() method can be use to determine
what legacy VRP supports, as irange::supports_p() will no longer be
applicable in the evrp analyzer code base once irange and prange are
split.

Tested on x86-64 Linux.

gcc/ChangeLog:

	* gimple-range-edge.cc (gimple_outgoing_range_stmt_p): Adjust for
	an object level supports_type_p for irange and a static
	Value_Range::supports_type_p.
	* gimple-range-fold.cc (fold_using_range::range_of_range_op): Same.
	(fold_using_range::range_of_address): Same.
	(fold_using_range::range_of_builtin_call): Same.
	* gimple-range-fold.h (gimple_range_type): Same.
	(gimple_range_ssa_p): Same.
	* gimple-range-path.cc (path_range_query::internal_range_of_expr):
	Same.
	(path_range_query::range_of_stmt): Same.
	(path_range_query::add_to_imports): Same.
	* gimple-range.cc (gimple_ranger::range_on_edge): Same.
	(gimple_ranger::export_global_ranges): Same.
	* gimple-ssa-evrp-analyze.cc
	(evrp_range_analyzer::record_ranges_from_phis):  Same.
	* range-op.cc (range_operator::wi_fold): Same.
	(range_operator::fold_range): Same.
	* tree-ssa-loop-ch.cc (entry_loop_condition_is_static): Same.
	* tree-ssa-loop-unswitch.cc (struct unswitch_predicate): Same.
	(evaluate_control_stmt_using_entry_checks): Same.
	* tree-ssa-threadedge.cc
	(hybrid_jt_simplifier::compute_ranges_from_state): Same.
	* tree-vrp.cc (supported_types_p): Same.
	* value-query.cc (range_query::value_of_expr): Same.
	(range_query::value_on_edge): Same.
	(range_query::value_of_stmt): Same.
	(range_query::get_tree_range): Same.
	(get_range_global): Same.
	(global_range_query::range_of_expr): Same.
	* value-range-equiv.h (class value_range_equiv): Same.
	* value-range.cc (irange::supports_type_p): Same.
	(unsupported_range::supports_type_p): Same.
	* value-range.h (enum value_range_discriminator): Same.
	(Value_Range::init): Same.
	(Value_Range::supports_type_p): Same.
	(irange::supports_type_p): Same.
	(irange::supports_p): Same.
	(vrange::supports_type_p): Same.
	(vrange_allocator::alloc_vrange): Same.

1 files changed, 33 insertions, 12 deletions

diff --git a/gcc/value-range.h b/gcc/value-range.h
index 5cd0e0e..69cf6c3 100644
--- a/gcc/value-range.h
+++ b/gcc/value-range.h
@@ -50,6 +50,23 @@ enum value_range_discriminator
 };
 
 // Abstract class for ranges of any of the supported types.
+//
+// To query what types ranger and the entire ecosystem can support,
+// use Value_Range::supports_type_p(tree type).  This is a static
+// method available independently of any vrange object.
+//
+// To query what a given vrange variant can support, use:
+//    irange::supports_p ()
+//    frange::supports_p ()
+//    etc
+//
+// To query what a range object can support, use:
+//    void foo (vrange &v, irange &i, frange &f)
+//    {
+//	if (v.supports_type_p (type)) ...
+//	if (i.supports_type_p (type)) ...
+//	if (f.supports_type_p (type)) ...
+//    }
 
 class vrange
 {
@@ -58,6 +75,7 @@ class vrange
 public:
   virtual void set (tree, tree, value_range_kind = VR_RANGE) = 0;
   virtual tree type () const = 0;
+  virtual bool supports_type_p (tree type) const = 0;
   virtual void set_varying (tree type) = 0;
   virtual void set_undefined () = 0;
   virtual void dump (FILE * = stderr) const = 0;
@@ -72,8 +90,6 @@ public:
   virtual void set_nonnegative (tree type) = 0;
   virtual bool fits_p (const vrange &r) const = 0;
 
-  static bool supports_type_p (tree);
-
   bool varying_p () const;
   bool undefined_p () const;
   vrange& operator= (const vrange &);
@@ -103,7 +119,8 @@ public:
   virtual void set_undefined () override;
 
   // Range types.
-  static bool supports_type_p (tree);
+  static bool supports_p (tree type);
+  virtual bool supports_type_p (tree type) const override;
   virtual tree type () const override;
 
   // Iteration over sub-ranges.
@@ -228,6 +245,7 @@ public:
   unsupported_range ();
   virtual void set (tree, tree, value_range_kind) override;
   virtual tree type () const override;
+  virtual bool supports_type_p (tree type) const override;
   virtual void set_varying (tree type) override;
   virtual void set_undefined () override;
   virtual void dump (FILE *) const override;
@@ -331,6 +349,7 @@ public:
   operator vrange &();
   operator const vrange &() const;
   void dump (FILE *out = stderr) const;
+  static bool supports_type_p (tree type);
 
   // Convenience methods for vrange compatability.
   void set (tree min, tree max, value_range_kind kind = VR_RANGE)
@@ -387,7 +406,7 @@ Value_Range::init (tree type)
 {
   gcc_checking_assert (TYPE_P (type));
 
-  if (irange::supports_type_p (type))
+  if (irange::supports_p (type))
     m_vrange = &m_irange;
   else
     m_vrange = &m_unsupported;
@@ -444,6 +463,14 @@ Value_Range::operator const vrange &() const
   return *m_vrange;
 }
 
+// Return TRUE if TYPE is supported by the vrange infrastructure.
+
+inline bool
+Value_Range::supports_type_p (tree type)
+{
+  return irange::supports_p (type);
+}
+
 // Returns true for an old-school value_range as described above.
 inline bool
 irange::legacy_mode_p () const
@@ -580,7 +607,7 @@ irange::nonzero_p () const
 }
 
 inline bool
-irange::supports_type_p (tree type)
+irange::supports_p (tree type)
 {
   return INTEGRAL_TYPE_P (type) || POINTER_TYPE_P (type);
 }
@@ -864,12 +891,6 @@ irange::normalize_kind ()
     }
 }
 
-inline bool
-vrange::supports_type_p (tree type)
-{
-  return irange::supports_type_p (type);
-}
-
 // Return the maximum value for TYPE.
 
 inline tree
@@ -944,7 +965,7 @@ vrange_allocator::alloc (unsigned bytes)
 inline vrange *
 vrange_allocator::alloc_vrange (tree type)
 {
-  if (irange::supports_type_p (type))
+  if (irange::supports_p (type))
     return alloc_irange (2);
 
   gcc_unreachable ();