Move operand_less_p to vr-values.c.

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index fecc494f380dc3d7c1eced024e0e249ecf7dbe34..5c90953edb1ff2dfac05a5090b8b9c2516895f6e 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,9 @@
+2020-05-17  Aldy Hernandez  <aldyh@redhat.com>
+
+       * tree-vrp.c (operand_less_p): Move to...
+       * vr-values.c (operand_less_p): ...here.
+       * tree-vrp.h (operand_less_p): Remove.
+
 2020-05-17  Aldy Hernandez  <aldyh@redhat.com>
 
        * tree-vrp.c (class vrp_insert): Remove prototype for

diff --git a/gcc/tree-vrp.c b/gcc/tree-vrp.c
index 4b5df543c00ebaa845a3e0a864dc96c01eb026d1..f8191facaf9c642023c9b78ced347c01572e1c0b 100644 (file)
--- a/gcc/tree-vrp.c
+++ b/gcc/tree-vrp.c
@@ -685,32 +685,6 @@ build_symbolic_expr (tree type, tree sym, bool neg, tree inv)
   return build2 (pointer_p ? POINTER_PLUS_EXPR : PLUS_EXPR, type, t, inv);
 }
 
-/* Return
-   1 if VAL < VAL2
-   0 if !(VAL < VAL2)
-   -2 if those are incomparable.  */
-int
-operand_less_p (tree val, tree val2)
-{
-  /* LT is folded faster than GE and others.  Inline the common case.  */
-  if (TREE_CODE (val) == INTEGER_CST && TREE_CODE (val2) == INTEGER_CST)
-    return tree_int_cst_lt (val, val2);
-  else if (TREE_CODE (val) == SSA_NAME && TREE_CODE (val2) == SSA_NAME)
-    return val == val2 ? 0 : -2;
-  else
-    {
-      int cmp = compare_values (val, val2);
-      if (cmp == -1)
-       return 1;
-      else if (cmp == 0 || cmp == 1)
-       return 0;
-      else
-       return -2;
-    }
-
-  return 0;
-}
-
 /* Compare two values VAL1 and VAL2.  Return
 
        -2 if VAL1 and VAL2 cannot be compared at compile-time,

diff --git a/gcc/tree-vrp.h b/gcc/tree-vrp.h
index aa8201f73593b26880a3f70991c25b1bd862c058..b74fe0059fcb3a863cf4ac355b42fee746219fc1 100644 (file)
--- a/gcc/tree-vrp.h
+++ b/gcc/tree-vrp.h
@@ -116,7 +116,6 @@ extern bool range_int_cst_p (const value_range *);
 
 extern int compare_values (tree, tree);
 extern int compare_values_warnv (tree, tree, bool *);
-extern int operand_less_p (tree, tree);
 
 void range_fold_unary_expr (value_range *, enum tree_code, tree type,
                            const value_range *, tree op0_type);

diff --git a/gcc/vr-values.c b/gcc/vr-values.c
index 2e3a0788710a049b5a58a4ce928212b37649d339..f7cba16aa6340fbac5fb7586c66f404180b5f81a 100644 (file)
--- a/gcc/vr-values.c
+++ b/gcc/vr-values.c
@@ -1104,6 +1104,32 @@ vr_values::check_for_binary_op_overflow (enum tree_code subcode, tree type,
   return true;
 }
 
+/* Return
+   1 if VAL < VAL2
+   0 if !(VAL < VAL2)
+   -2 if those are incomparable.  */
+static int
+operand_less_p (tree val, tree val2)
+{
+  /* LT is folded faster than GE and others.  Inline the common case.  */
+  if (TREE_CODE (val) == INTEGER_CST && TREE_CODE (val2) == INTEGER_CST)
+    return tree_int_cst_lt (val, val2);
+  else if (TREE_CODE (val) == SSA_NAME && TREE_CODE (val2) == SSA_NAME)
+    return val == val2 ? 0 : -2;
+  else
+    {
+      int cmp = compare_values (val, val2);
+      if (cmp == -1)
+       return 1;
+      else if (cmp == 0 || cmp == 1)
+       return 0;
+      else
+       return -2;
+    }
+
+  return 0;
+}
+
 /* Try to derive a nonnegative or nonzero range out of STMT relying
    primarily on generic routines in fold in conjunction with range data.
    Store the result in *VR */