[gcc(refs/users/aldyh/heads/ranger-staging)] Revert determine_value_range changes.

[gcc(refs/users/aldyh/heads/ranger-staging)] Revert determine_value_range changes.

[Aldy Hernandez]

https://gcc.gnu.org/g:73b8ac3a6e231958a1132688aa5b8f371dd2d7e5

commit 73b8ac3a6e231958a1132688aa5b8f371dd2d7e5
Author: Aldy Hernandez <aldyh@redhat.com>
Date:   Fri Oct 2 11:43:22 2020 +0200

    Revert determine_value_range changes.

Diff:
---
 gcc/calls.c                    | 11 ++---------
 gcc/calls.h                    |  1 -
 gcc/gimple-ssa-warn-restrict.c |  6 +++---
 gcc/tree-affine.c              |  2 +-
 gcc/tree-vrp.c                 | 13 ++++++-------
 gcc/tree-vrp.h                 |  3 +--
 6 files changed, 13 insertions(+), 23 deletions(-)

diff --git a/gcc/calls.c b/gcc/calls.c
index db684c4e3f7..ed4363811c8 100644
--- a/gcc/calls.c
+++ b/gcc/calls.c
@@ -1251,8 +1251,7 @@ alloc_max_size (void)
    functions like memset.  */
 
 bool
-get_size_range (tree exp, gimple *stmt, tree range[2],
-		bool allow_zero /* = false */)
+get_size_range (tree exp, tree range[2], bool allow_zero /* = false */)
 {
   if (!exp)
     return false;
@@ -1271,7 +1270,7 @@ get_size_range (tree exp, gimple *stmt, tree range[2],
   enum value_range_kind range_type;
 
   if (integral)
-    range_type = determine_value_range (exp, stmt, &min, &max);
+    range_type = determine_value_range (exp, &min, &max);
   else
     range_type = VR_VARYING;
 
@@ -1352,12 +1351,6 @@ get_size_range (tree exp, gimple *stmt, tree range[2],
   return true;
 }
 
-bool
-get_size_range (tree exp, tree range[2], bool allow_zero /* = false */)
-{
-  return get_size_range (exp, NULL, range, allow_zero);
-}
-
 /* Diagnose a call EXP to function FN decorated with attribute alloc_size
    whose argument numbers given by IDX with values given by ARGS exceed
    the maximum object size or cause an unsigned oveflow (wrapping) when
diff --git a/gcc/calls.h b/gcc/calls.h
index 0784fb28430..dfb951ca45b 100644
--- a/gcc/calls.h
+++ b/gcc/calls.h
@@ -134,7 +134,6 @@ extern void maybe_warn_alloc_args_overflow (tree, tree, tree[2], int[2]);
 extern tree get_attr_nonstring_decl (tree, tree * = NULL);
 extern bool maybe_warn_nonstring_arg (tree, tree);
 extern bool get_size_range (tree, tree[2], bool = false);
-extern bool get_size_range (tree, gimple *, tree[2], bool = false);
 extern rtx rtx_for_static_chain (const_tree, bool);
 extern bool cxx17_empty_base_field_p (const_tree);
 
diff --git a/gcc/gimple-ssa-warn-restrict.c b/gcc/gimple-ssa-warn-restrict.c
index 543a75c43d0..7d1aa9c17fd 100644
--- a/gcc/gimple-ssa-warn-restrict.c
+++ b/gcc/gimple-ssa-warn-restrict.c
@@ -250,7 +250,7 @@ builtin_memref::builtin_memref (gimple *stmt, tree expr, tree size)
       tree range[2];
       /* Determine the size range, allowing for the result to be [0, 0]
 	 for SIZE in the anti-range ~[0, N] where N >= PTRDIFF_MAX.  */
-      get_size_range (size, stmt, range, true);
+      get_size_range (size, range, true);
       sizrange[0] = wi::to_offset (range[0]);
       sizrange[1] = wi::to_offset (range[1]);
       /* get_size_range returns SIZE_MAX for the maximum size.
@@ -327,7 +327,7 @@ builtin_memref::extend_offset_range (tree offset)
       /* A pointer offset is represented as sizetype but treated
 	 as signed.  */
       wide_int min, max;
-      value_range_kind rng = determine_value_range (offset, stmt, &min, &max);
+      value_range_kind rng = get_range_info (offset, &min, &max);
       if (rng == VR_ANTI_RANGE && wi::lts_p (max, min))
 	{
 	  /* Convert an anti-range whose upper bound is less than
@@ -783,7 +783,7 @@ builtin_access::builtin_access (gimple *call, builtin_memref &dst,
 
       tree size = gimple_call_arg (call, sizeargno);
       tree range[2];
-      if (get_size_range (size, call, range, true))
+      if (get_size_range (size, range, true))
 	{
 	  bounds[0] = wi::to_offset (range[0]);
 	  bounds[1] = wi::to_offset (range[1]);
diff --git a/gcc/tree-affine.c b/gcc/tree-affine.c
index 4c9ecd5479f..5620e6bf28f 100644
--- a/gcc/tree-affine.c
+++ b/gcc/tree-affine.c
@@ -348,7 +348,7 @@ expr_to_aff_combination (aff_tree *comb, tree_code code, tree type,
 	    if (TYPE_UNSIGNED (itype)
 		&& TYPE_OVERFLOW_WRAPS (itype)
 		&& TREE_CODE (op1) == INTEGER_CST
-		&& determine_value_range (op0, NULL, &minv, &maxv) == VR_RANGE)
+		&& determine_value_range (op0, &minv, &maxv) == VR_RANGE)
 	      {
 		wi::overflow_type overflow = wi::OVF_NONE;
 		signop sign = UNSIGNED;
diff --git a/gcc/tree-vrp.c b/gcc/tree-vrp.c
index eb8563b5423..0e19690f41f 100644
--- a/gcc/tree-vrp.c
+++ b/gcc/tree-vrp.c
@@ -66,7 +66,6 @@ along with GCC; see the file COPYING3.  If not see
 #include "range-op.h"
 #include "value-range-equiv.h"
 #include "gimple-array-bounds.h"
-#include "gimple-range.h"
 
 /* Set of SSA names found live during the RPO traversal of the function
    for still active basic-blocks.  */
@@ -4565,20 +4564,20 @@ make_pass_vrp (gcc::context *ctxt)
 /* Worker for determine_value_range.  */
 
 static void
-determine_value_range_1 (value_range *vr, tree expr, gimple *stmt)
+determine_value_range_1 (value_range *vr, tree expr)
 {
   if (BINARY_CLASS_P (expr))
     {
       value_range vr0, vr1;
-      determine_value_range_1 (&vr0, TREE_OPERAND (expr, 0), stmt);
-      determine_value_range_1 (&vr1, TREE_OPERAND (expr, 1), stmt);
+      determine_value_range_1 (&vr0, TREE_OPERAND (expr, 0));
+      determine_value_range_1 (&vr1, TREE_OPERAND (expr, 1));
       range_fold_binary_expr (vr, TREE_CODE (expr), TREE_TYPE (expr),
 			      &vr0, &vr1);
     }
   else if (UNARY_CLASS_P (expr))
     {
       value_range vr0;
-      determine_value_range_1 (&vr0, TREE_OPERAND (expr, 0), stmt);
+      determine_value_range_1 (&vr0, TREE_OPERAND (expr, 0));
       range_fold_unary_expr (vr, TREE_CODE (expr), TREE_TYPE (expr),
 			     &vr0, TREE_TYPE (TREE_OPERAND (expr, 0)));
     }
@@ -4605,10 +4604,10 @@ determine_value_range_1 (value_range *vr, tree expr, gimple *stmt)
    the determined range type.  */
 
 value_range_kind
-determine_value_range (tree expr, gimple *stmt, wide_int *min, wide_int *max)
+determine_value_range (tree expr, wide_int *min, wide_int *max)
 {
   value_range vr;
-  determine_value_range_1 (&vr, expr, stmt);
+  determine_value_range_1 (&vr, expr);
   if (vr.constant_p ())
     {
       *min = wi::to_wide (vr.min ());
diff --git a/gcc/tree-vrp.h b/gcc/tree-vrp.h
index bc529f604d2..eadfd71e1b9 100644
--- a/gcc/tree-vrp.h
+++ b/gcc/tree-vrp.h
@@ -62,8 +62,7 @@ extern bool find_case_label_index (gswitch *, size_t, tree, size_t *);
 extern bool overflow_comparison_p (tree_code, tree, tree, bool, tree *);
 extern tree get_single_symbol (tree, bool *, tree *);
 extern void maybe_set_nonzero_bits (edge, tree);
-extern value_range_kind determine_value_range (tree, gimple *,
-					       wide_int *, wide_int *);
+extern value_range_kind determine_value_range (tree, wide_int *, wide_int *);
 extern wide_int masked_increment (const wide_int &val_in, const wide_int &mask,
 				  const wide_int &sgnbit, unsigned int prec);