[gcc r13-2799] Convert CFN_BUILT_IN_PARITY to range-ops.

[gcc r13-2799] Convert CFN_BUILT_IN_PARITY to range-ops.

[Andrew Macleod]

https://gcc.gnu.org/g:5608e410914ebb7c8cc9fa50afc8ada3b22cbf2c

commit r13-2799-g5608e410914ebb7c8cc9fa50afc8ada3b22cbf2c
Author: Andrew MacLeod <amacleod@redhat.com>
Date:   Tue Sep 20 19:30:46 2022 -0400

    Convert CFN_BUILT_IN_PARITY to range-ops.
    
    Also, as the last builtin remaining, also remove the builtin infrastrucure
    routines from fold_using_range.
    
            * gimple-range-fold.cc (range_of_range_op): Handle no operands.
            (range_of_call): Do not check for builtins.
            (fold_using_range::range_of_builtin_call): Delete.
            (fold_using_range::range_of_builtin_int_call): Delete.
            * gimple-range-fold.h: Adjust prototypes.
            * gimple-range-op.cc (class cfn_parity): New.
            (gimple_range_op_handler::maybe_builtin_call): Set arguments.

Diff:
---
 gcc/gimple-range-fold.cc | 60 ++++++++++--------------------------------------
 gcc/gimple-range-fold.h  |  4 ----
 gcc/gimple-range-op.cc   | 19 +++++++++++++++
 3 files changed, 31 insertions(+), 52 deletions(-)

diff --git a/gcc/gimple-range-fold.cc b/gcc/gimple-range-fold.cc
index 5e8a13e7337..c381ef94087 100644
--- a/gcc/gimple-range-fold.cc
+++ b/gcc/gimple-range-fold.cc
@@ -534,6 +534,16 @@ fold_using_range::range_of_range_op (vrange &r,
   tree lhs = handler.lhs ();
   tree op1 = handler.operand1 ();
   tree op2 = handler.operand2 ();
+
+  // Certain types of builtin functions may have no arguments.
+  if (!op1)
+    {
+      Value_Range r1 (type);
+      if (!handler.fold_range (r, type, r1, r1))
+	r.set_varying (type);
+      return true;
+    }
+
   Value_Range range1 (TREE_TYPE (op1));
   Value_Range range2 (op2 ? TREE_TYPE (op2) : TREE_TYPE (op1));
 
@@ -823,7 +833,7 @@ fold_using_range::range_of_phi (vrange &r, gphi *phi, fur_source &src)
 // If a range cannot be calculated, return false.
 
 bool
-fold_using_range::range_of_call (vrange &r, gcall *call, fur_source &src)
+fold_using_range::range_of_call (vrange &r, gcall *call, fur_source &)
 {
   tree type = gimple_range_type (call);
   if (!type)
@@ -832,9 +842,7 @@ fold_using_range::range_of_call (vrange &r, gcall *call, fur_source &src)
   tree lhs = gimple_call_lhs (call);
   bool strict_overflow_p;
 
-  if (range_of_builtin_call (r, call, src))
-    ;
-  else if (gimple_stmt_nonnegative_warnv_p (call, &strict_overflow_p))
+  if (gimple_stmt_nonnegative_warnv_p (call, &strict_overflow_p))
     r.set_nonnegative (type);
   else if (gimple_call_nonnull_result_p (call)
 	   || gimple_call_nonnull_arg (call))
@@ -852,50 +860,6 @@ fold_using_range::range_of_call (vrange &r, gcall *call, fur_source &src)
   return true;
 }
 
-// For a builtin in CALL, return a range in R if known and return
-// TRUE.  Otherwise return FALSE.
-
-bool
-fold_using_range::range_of_builtin_call (vrange &r, gcall *call,
-					 fur_source &src)
-{
-  combined_fn func = gimple_call_combined_fn (call);
-  if (func == CFN_LAST)
-    return false;
-
-  tree type = gimple_range_type (call);
-  gcc_checking_assert (type);
-
-  if (irange::supports_p (type))
-    return range_of_builtin_int_call (as_a <irange> (r), call, src);
-
-  return false;
-}
-
-bool
-fold_using_range::range_of_builtin_int_call (irange &r, gcall *call,
-					     fur_source &)
-{
-  combined_fn func = gimple_call_combined_fn (call);
-  if (func == CFN_LAST)
-    return false;
-
-  tree type = gimple_range_type (call);
-  scalar_int_mode mode;
-
-  switch (func)
-    {
-    CASE_CFN_PARITY:
-      r.set (build_zero_cst (type), build_one_cst (type));
-      return true;
-
-    default:
-      break;
-    }
-  return false;
-}
-
-
 // Calculate a range for COND_EXPR statement S and return it in R.
 // If a range cannot be calculated, return false.
 
diff --git a/gcc/gimple-range-fold.h b/gcc/gimple-range-fold.h
index ce18c66b8e7..d1ed2bca80f 100644
--- a/gcc/gimple-range-fold.h
+++ b/gcc/gimple-range-fold.h
@@ -165,10 +165,6 @@ protected:
   bool range_of_call (vrange &r, gcall *call, fur_source &src);
   bool range_of_cond_expr (vrange &r, gassign* cond, fur_source &src);
   bool range_of_address (irange &r, gimple *s, fur_source &src);
-  bool range_of_builtin_call (vrange &r, gcall *call, fur_source &src);
-  bool range_of_builtin_int_call (irange &r, gcall *call, fur_source &src);
-  void range_of_builtin_ubsan_call (irange &r, gcall *call, tree_code code,
-				    fur_source &src);
   bool range_of_phi (vrange &r, gphi *phi, fur_source &src);
   void range_of_ssa_name_with_loop_info (vrange &, tree, class loop *, gphi *,
 					 fur_source &src);
diff --git a/gcc/gimple-range-op.cc b/gcc/gimple-range-op.cc
index 76295466e65..d7c6dfa933d 100644
--- a/gcc/gimple-range-op.cc
+++ b/gcc/gimple-range-op.cc
@@ -663,6 +663,20 @@ private:
   bool m_is_pos;
 } op_cfn_goacc_dim_size (false), op_cfn_goacc_dim_pos (true);
 
+
+// Implement range operator for CFN_BUILT_IN_
+class cfn_parity : public range_operator
+{
+public:
+  using range_operator::fold_range;
+  virtual bool fold_range (irange &r, tree type, const irange &,
+			   const irange &, relation_kind) const
+  {
+    r.set (build_zero_cst (type), build_one_cst (type));
+    return true;
+  }
+} op_cfn_parity;
+
 // Set up a gimple_range_op_handler for any built in function which can be
 // supported via range-ops.
 
@@ -795,6 +809,11 @@ gimple_range_op_handler::maybe_builtin_call ()
       m_int = &op_cfn_goacc_dim_pos;
       break;
 
+    CASE_CFN_PARITY:
+      m_valid = true;
+      m_int = &op_cfn_parity;
+      break;
+
     default:
       break;
     }