diff mbox series

tree-optimization/101254 - Fix MINUS_EXPR relations.

Message ID 92d16f72-bb76-ff16-1536-1bc7ba1e4482@redhat.com
State New
Headers show
Series tree-optimization/101254 - Fix MINUS_EXPR relations. | expand

Commit Message

Andrew MacLeod June 29, 2021, 7:10 p.m. UTC 
We were incorrectly calculating the LHS of a MINUS_EXPR for wrapping 
signed values.  This patch cleans that up and fully fleshed out the 
possible LHS of OP1 - OP2 given a known relation between them.

Bootstraps on x86_64-pc-linux-gnu with no regressions.  Pushed.

Andrew
diff mbox series

Patch

From a96d8d67d0073a7031c0712bc3fb7759417b2125 Mon Sep 17 00:00:00 2001
From: Andrew MacLeod <amacleod@redhat.com>
Date: Tue, 29 Jun 2021 10:52:58 -0400
Subject: [PATCH 3/3] Fix MINUS_EXPR relations.

Flesh out and correct relations for both wrapping and non-wrapping values.

	gcc/
	PR tree-optimization/101254
	* range-op.cc (operator_minus::op1_op2_relation_effect): Check for
	wrapping/non-wrapping when setting the result range.

	gcc/testsuite
	* gcc.dg/pr101254.c: New.
---
 gcc/range-op.cc                 | 64 ++++++++++++++++++++++++---------
 gcc/testsuite/gcc.dg/pr101254.c | 27 ++++++++++++++
 2 files changed, 74 insertions(+), 17 deletions(-)
 create mode 100644 gcc/testsuite/gcc.dg/pr101254.c

diff --git a/gcc/range-op.cc b/gcc/range-op.cc
index 29ee9e0f645..97b9843e095 100644
--- a/gcc/range-op.cc
+++ b/gcc/range-op.cc
@@ -1314,24 +1314,54 @@  operator_minus::op1_op2_relation_effect (irange &lhs_range, tree type,
   unsigned prec = TYPE_PRECISION (type);
   signop sgn = TYPE_SIGN (type);
 
-  switch (rel)
+  // == and != produce [0,0] and ~[0,0] regardless of wrapping.
+  if (rel == EQ_EXPR)
+    rel_range = int_range<2> (type, wi::zero (prec), wi::zero (prec));
+  else if (rel == NE_EXPR)
+    rel_range = int_range<2> (type, wi::zero (prec), wi::zero (prec),
+			      VR_ANTI_RANGE);
+  else if (TYPE_OVERFLOW_WRAPS (type))
     {
-      // op1 > op2,  op1 - op2 can be restricted to  [1, max]
-      case GT_EXPR:
-	rel_range = int_range<2> (type, wi::one (prec),
-				  wi::max_value (prec, sgn));
-	break;
-      // op1 >= op2,  op1 - op2 can be restricted to  [0, max]
-      case GE_EXPR:
-	rel_range = int_range<2> (type, wi::zero (prec),
-				  wi::max_value (prec, sgn));
-	break;
-      // op1 == op2,  op1 - op2 can be restricted to  [0, 0]
-      case EQ_EXPR:
-	rel_range = int_range<2> (type, wi::zero (prec), wi::zero (prec));
-	break;
-      default:
-	return false;
+      switch (rel)
+	{
+	  // For wrapping signed values and unsigned, if op1 > op2 or
+	  // op1 < op2, then op1 - op2 can be restricted to ~[0, 0].
+	  case GT_EXPR:
+	  case LT_EXPR:
+	      rel_range = int_range<2> (type, wi::zero (prec), wi::zero (prec),
+					VR_ANTI_RANGE);
+	    break;
+	  default:
+	    return false;
+	}
+    }
+  else
+    {
+      switch (rel)
+	{
+	  // op1 > op2, op1 - op2 can be restricted to [1, +INF]
+	  case GT_EXPR:
+	    rel_range = int_range<2> (type, wi::one (prec),
+				      wi::max_value (prec, sgn));
+	    break;
+	  // op1 >= op2, op1 - op2 can be restricted to [0, +INF]
+	  case GE_EXPR:
+	    rel_range = int_range<2> (type, wi::zero (prec),
+				      wi::max_value (prec, sgn));
+	    break;
+	  // op1 < op2, op1 - op2 can be restricted to [-INF, -1]
+	  case LT_EXPR:
+	    rel_range = int_range<2> (type, wi::min_value (prec, sgn),
+				      wi::minus_one (prec));
+	    break;
+	  // op1 <= op2, op1 - op2 can be restricted to [-INF, 0]
+	  case LE_EXPR:
+	    rel_range = int_range<2> (type, wi::min_value (prec, sgn),
+				      wi::zero (prec));
+	    break;
+	  default:
+	    return false;
+	}
     }
   lhs_range.intersect (rel_range);
   return true;
diff --git a/gcc/testsuite/gcc.dg/pr101254.c b/gcc/testsuite/gcc.dg/pr101254.c
new file mode 100644
index 00000000000..b2460ed86f3
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/pr101254.c
@@ -0,0 +1,27 @@ 
+/* PR tree-optimization/101254 */
+/* { dg-do run } */
+/* { dg-options "-O2 -fwrapv" } */
+
+int
+foo (long long imin, long long imax)
+{
+  if (imin > imax)
+    return 0;
+  else if (imax - imin < 0 || (imax - imin) + 1 < 0)
+    return 0;
+  return 1;
+}
+
+int
+main ()
+{
+  long long imax = __LONG_LONG_MAX__;
+  long long imin = -imax - 1; 
+  if (!foo (-10, 10))
+    __builtin_abort ();
+  if (foo (-10, imax))
+    __builtin_abort ();
+  if (foo (imin, imax))
+    __builtin_abort ();
+  return 0;
+}
-- 
2.17.2