Implement operator_not_equal for prange.

gcc/ChangeLog:

	* range-op-mixed.h: Add overloaded declarations for pointer variants.
	* range-op-ptr.cc (operator_not_equal::fold_range): New.
	(operator_not_equal::op1_range): New.
	(operator_not_equal::op2_range): New.
	(operator_not_equal::op1_op2_relation): New.
	(operator_not_equal::pointers_handled_p): New.

2 files changed, 130 insertions, 0 deletions

diff --git a/gcc/range-op-mixed.h b/gcc/range-op-mixed.h
index c45aed9..980611d 100644
--- a/gcc/range-op-mixed.h
+++ b/gcc/range-op-mixed.h
@@ -156,12 +156,18 @@ public:
 		   const irange &op1, const irange &op2,
 		   relation_trio = TRIO_VARYING) const final override;
   bool fold_range (irange &r, tree type,
+		   const prange &op1, const prange &op2,
+		   relation_trio rel = TRIO_VARYING) const final override;
+  bool fold_range (irange &r, tree type,
 		   const frange &op1, const frange &op2,
 		   relation_trio rel = TRIO_VARYING) const final override;
 
   bool op1_range (irange &r, tree type,
 		  const irange &lhs, const irange &op2,
 		  relation_trio = TRIO_VARYING) const final override;
+  bool op1_range (prange &r, tree type,
+		  const irange &lhs, const prange &op2,
+		  relation_trio = TRIO_VARYING) const final override;
   bool op1_range (frange &r, tree type,
 		  const irange &lhs, const frange &op2,
 		  relation_trio = TRIO_VARYING) const final override;
@@ -169,12 +175,17 @@ public:
   bool op2_range (irange &r, tree type,
 		  const irange &lhs, const irange &op1,
 		  relation_trio = TRIO_VARYING) const final override;
+  bool op2_range (prange &r, tree type,
+		  const irange &lhs, const prange &op1,
+		  relation_trio = TRIO_VARYING) const final override;
   bool op2_range (frange &r, tree type,
 		  const irange &lhs, const frange &op1,
 		  relation_trio = TRIO_VARYING) const final override;
 
   relation_kind op1_op2_relation (const irange &lhs, const irange &,
 				  const irange &) const final override;
+  relation_kind op1_op2_relation (const irange &lhs, const prange &,
+				  const prange &) const final override;
   relation_kind op1_op2_relation (const irange &lhs, const frange &,
 				  const frange &) const final override;
   void update_bitmask (irange &r, const irange &lh,
@@ -182,6 +193,7 @@ public:
   // Check op1 and op2 for compatibility.
   bool operand_check_p (tree, tree t1, tree t2) const final override
     { return range_compatible_p (t1, t2); }
+  bool pointers_handled_p (range_op_dispatch_type, unsigned) const final override;
 };
 
 class operator_lt :  public range_operator
diff --git a/gcc/range-op-ptr.cc b/gcc/range-op-ptr.cc
index 2f2f4bb..081e8fd 100644
--- a/gcc/range-op-ptr.cc
+++ b/gcc/range-op-ptr.cc
@@ -1230,6 +1230,124 @@ operator_bitwise_or::pointers_handled_p (range_op_dispatch_type,
   return false;
 }
 
+bool
+operator_not_equal::fold_range (irange &r, tree type,
+				const prange &op1,
+				const prange &op2,
+				relation_trio rel) const
+{
+  if (relop_early_resolve (r, type, op1, op2, rel, VREL_NE))
+    return true;
+
+  // We can be sure the values are always equal or not if both ranges
+  // consist of a single value, and then compare them.
+  bool op1_const = wi::eq_p (op1.lower_bound (), op1.upper_bound ());
+  bool op2_const = wi::eq_p (op2.lower_bound (), op2.upper_bound ());
+  if (op1_const && op2_const)
+    {
+      if (wi::ne_p (op1.lower_bound (), op2.upper_bound()))
+	r = range_true ();
+      else
+	r = range_false ();
+    }
+  else
+    {
+      // If ranges do not intersect, we know the range is not equal,
+      // otherwise we don't know anything for sure.
+      prange tmp = op1;
+      tmp.intersect (op2);
+      if (tmp.undefined_p ())
+	r = range_true ();
+      // Check if a constant cannot satisfy the bitmask requirements.
+      else if (op2_const && !op1.get_bitmask ().member_p (op2.lower_bound ()))
+	 r = range_true ();
+      else if (op1_const && !op2.get_bitmask ().member_p (op1.lower_bound ()))
+	 r = range_true ();
+      else
+	r = range_true_and_false ();
+    }
+
+  //update_known_bitmask (r, NE_EXPR, op1, op2);
+  return true;
+}
+
+bool
+operator_not_equal::op1_range (prange &r, tree type,
+			       const irange &lhs,
+			       const prange &op2,
+			       relation_trio) const
+{
+  switch (get_bool_state (r, lhs, type))
+    {
+    case BRS_TRUE:
+      // If the result is true, the only time we know anything is if
+      // OP2 is a constant.
+      if (!op2.undefined_p ()
+	  && wi::eq_p (op2.lower_bound(), op2.upper_bound()))
+	{
+	  r = op2;
+	  r.invert ();
+	}
+      else
+	r.set_varying (type);
+      break;
+
+    case BRS_FALSE:
+      // If it's false, the result is the same as OP2.
+      r = op2;
+      break;
+
+    default:
+      break;
+    }
+  return true;
+}
+
+
+bool
+operator_not_equal::op2_range (prange &r, tree type,
+			       const irange &lhs,
+			       const prange &op1,
+			       relation_trio rel) const
+{
+  return operator_not_equal::op1_range (r, type, lhs, op1, rel.swap_op1_op2 ());
+}
+
+relation_kind
+operator_not_equal::op1_op2_relation (const irange &lhs, const prange &,
+				      const prange &) const
+{
+  if (lhs.undefined_p ())
+    return VREL_UNDEFINED;
+
+  // FALSE = op1 != op2  indicates EQ_EXPR.
+  if (lhs.zero_p ())
+    return VREL_EQ;
+
+  // TRUE = op1 != op2  indicates NE_EXPR.
+  if (!range_includes_zero_p (lhs))
+    return VREL_NE;
+  return VREL_VARYING;
+}
+
+bool
+operator_not_equal::pointers_handled_p (range_op_dispatch_type type,
+					unsigned dispatch) const
+{
+  switch (type)
+    {
+    case DISPATCH_FOLD_RANGE:
+      return dispatch == RO_IPP;
+    case DISPATCH_OP1_RANGE:
+    case DISPATCH_OP2_RANGE:
+      return dispatch == RO_PIP;
+    case DISPATCH_OP1_OP2_RELATION:
+      return dispatch == RO_IPP;
+    default:
+      return true;
+    }
+}
+
 // Initialize any pointer operators to the primary table
 
 void