Split gimple-range into gimple-range-fold and gimple-range.

Split the fold_using_range functions from gimple-range into gimple-range-fold.
Also move the gimple_range_calc* routines into gimple-range-gori.

	* Makefile.in (OBJS): Add gimple-range-fold.o
	* gimple-range-fold.cc: New.
	* gimple-range-fold.h: New.
	* gimple-range-gori.cc (gimple_range_calc_op1): Move to here.
	(gimple_range_calc_op2): Ditto.
	* gimple-range-gori.h: Move prototypes to here.
	* gimple-range.cc: Adjust include files.
	(fur_source:fur_source): Relocate to gimple-range-fold.cc.
	(fur_source::get_operand): Ditto.
	(fur_source::get_phi_operand): Ditto.
	(fur_source::query_relation): Ditto.
	(fur_source::register_relation): Ditto.
	(class fur_edge): Ditto.
	(fur_edge::fur_edge): Ditto.
	(fur_edge::get_operand): Ditto.
	(fur_edge::get_phi_operand): Ditto.
	(fur_stmt::fur_stmt): Ditto.
	(fur_stmt::get_operand): Ditto.
	(fur_stmt::get_phi_operand): Ditto.
	(fur_stmt::query_relation): Ditto.
	(class fur_depend): Relocate to gimple-range-fold.h.
	(fur_depend::fur_depend): Relocate to gimple-range-fold.cc.
	(fur_depend::register_relation): Ditto.
	(fur_depend::register_relation): Ditto.
	(class fur_list): Ditto.
	(fur_list::fur_list): Ditto.
	(fur_list::get_operand): Ditto.
	(fur_list::get_phi_operand): Ditto.
	(fold_range): Ditto.
	(adjust_pointer_diff_expr): Ditto.
	(gimple_range_adjustment): Ditto.
	(gimple_range_base_of_assignment): Ditto.
	(gimple_range_operand1): Ditto.
	(gimple_range_operand2): Ditto.
	(gimple_range_calc_op1): Relocate to gimple-range-gori.cc.
	(gimple_range_calc_op2): Ditto.
	(fold_using_range::fold_stmt): Relocate to gimple-range-fold.cc.
	(fold_using_range::range_of_range_op): Ditto.
	(fold_using_range::range_of_address): Ditto.
	(fold_using_range::range_of_phi): Ditto.
	(fold_using_range::range_of_call): Ditto.
	(fold_using_range::range_of_builtin_ubsan_call): Ditto.
	(fold_using_range::range_of_builtin_call): Ditto.
	(fold_using_range::range_of_cond_expr): Ditto.
	(fold_using_range::range_of_ssa_name_with_loop_info): Ditto.
	(fold_using_range::relation_fold_and_or): Ditto.
	(fold_using_range::postfold_gcond_edges): Ditto.
	* gimple-range.h: Add gimple-range-fold.h to include files. Change
	GIMPLE_RANGE_STMT_H to GIMPLE_RANGE_H.
	(gimple_range_handler): Relocate to gimple-range-fold.h.
	(gimple_range_ssa_p): Ditto.
	(range_compatible_p): Ditto.
	(class fur_source): Ditto.
	(class fur_stmt): Ditto.
	(class fold_using_range): Ditto.
	(gimple_range_calc_op1): Relocate to gimple-range-gori.h
	(gimple_range_calc_op2): Ditto.

1 files changed, 66 insertions, 0 deletions

diff --git a/gcc/gimple-range-gori.cc b/gcc/gimple-range-gori.cc
index b58f249..17032ac 100644
--- a/gcc/gimple-range-gori.cc
+++ b/gcc/gimple-range-gori.cc
@@ -29,6 +29,72 @@ along with GCC; see the file COPYING3.  If not see
 #include "gimple-pretty-print.h"
 #include "gimple-range.h"
 
+// Calculate what we can determine of the range of this unary
+// statement's operand if the lhs of the expression has the range
+// LHS_RANGE.  Return false if nothing can be determined.
+
+bool
+gimple_range_calc_op1 (irange &r, const gimple *stmt, const irange &lhs_range)
+{
+  gcc_checking_assert (gimple_num_ops (stmt) < 3);
+
+  // An empty range is viral.
+  tree type = TREE_TYPE (gimple_range_operand1 (stmt));
+  if (lhs_range.undefined_p ())
+    {
+      r.set_undefined ();
+      return true;
+    }
+  // Unary operations require the type of the first operand in the
+  // second range position.
+  int_range<2> type_range (type);
+  return gimple_range_handler (stmt)->op1_range (r, type, lhs_range,
+						 type_range);
+}
+
+// Calculate what we can determine of the range of this statement's
+// first operand if the lhs of the expression has the range LHS_RANGE
+// and the second operand has the range OP2_RANGE.  Return false if
+// nothing can be determined.
+
+bool
+gimple_range_calc_op1 (irange &r, const gimple *stmt,
+		       const irange &lhs_range, const irange &op2_range)
+{
+  // Unary operation are allowed to pass a range in for second operand
+  // as there are often additional restrictions beyond the type which
+  // can be imposed.  See operator_cast::op1_range().
+  tree type = TREE_TYPE (gimple_range_operand1 (stmt));
+  // An empty range is viral.
+  if (op2_range.undefined_p () || lhs_range.undefined_p ())
+    {
+      r.set_undefined ();
+      return true;
+    }
+  return gimple_range_handler (stmt)->op1_range (r, type, lhs_range,
+						 op2_range);
+}
+
+// Calculate what we can determine of the range of this statement's
+// second operand if the lhs of the expression has the range LHS_RANGE
+// and the first operand has the range OP1_RANGE.  Return false if
+// nothing can be determined.
+
+bool
+gimple_range_calc_op2 (irange &r, const gimple *stmt,
+		       const irange &lhs_range, const irange &op1_range)
+{
+  tree type = TREE_TYPE (gimple_range_operand2 (stmt));
+  // An empty range is viral.
+  if (op1_range.undefined_p () || lhs_range.undefined_p ())
+    {
+      r.set_undefined ();
+      return true;
+    }
+  return gimple_range_handler (stmt)->op2_range (r, type, lhs_range,
+						 op1_range);
+}
+
 // Return TRUE if GS is a logical && or || expression.
 
 static inline bool