range-ops: (nonzero | X) is nonzero

Message ID 20210615114838.151530-1-aldyh@redhat.com
State New
Headers show
Series
  • range-ops: (nonzero | X) is nonzero
Related show

Commit Message

Martin Sebor via Gcc-patches June 15, 2021, 11:48 a.m.
For bitwise or, nonzero|X is always nonzero.  Make sure we don't drop to
varying in this case.

This was found while examining differences between VRP/DOM threaders and
the upcoming work, but it could be useful for any user of range-ops.

Tested on x86-64 Linux.

OK?

gcc/ChangeLog:

	* range-op.cc (operator_bitwise_or::wi_fold): Make sure
	nonzero|X is nonzero.
	(range_op_bitwise_and_tests): Add tests for above.
---
 gcc/range-op.cc | 28 ++++++++++++++++++++++++----
 1 file changed, 24 insertions(+), 4 deletions(-)

-- 
2.31.1

Comments

Martin Sebor via Gcc-patches June 15, 2021, 12:39 p.m. | #1
On 15 June 2021 13:48:39 CEST, Aldy Hernandez via Gcc-patches <gcc-patches@gcc.gnu.org> wrote:
>For bitwise or, nonzero|X is always nonzero.  Make sure we don't drop

>to

>varying in this case.

>

>This was found while examining differences between VRP/DOM threaders

>and

>the upcoming work, but it could be useful for any user of range-ops.

>

>Tested on x86-64 Linux.

>

>OK?

>

>gcc/ChangeLog:

>

>	* range-op.cc (operator_bitwise_or::wi_fold): Make sure

>	nonzero|X is nonzero.

>	(range_op_bitwise_and_tests): Add tests for above.

>---

> gcc/range-op.cc | 28 ++++++++++++++++++++++++----

> 1 file changed, 24 insertions(+), 4 deletions(-)

>

>diff --git a/gcc/range-op.cc b/gcc/range-op.cc

>index 742e54686b4..59978466b45 100644

>--- a/gcc/range-op.cc

>+++ b/gcc/range-op.cc

>@@ -2534,11 +2534,20 @@ operator_bitwise_or::wi_fold (irange &r, tree

>type,

>     new_lb = wi::max (new_lb, lh_lb, sign);

>   if (wi::lt_p (rh_ub, 0, sign))

>     new_lb = wi::max (new_lb, rh_lb, sign);

>-  // If the limits got swapped around, return varying.

>+  // If the limits got swapped around, return a conservative range.

>   if (wi::gt_p (new_lb, new_ub,sign))


Missing space before sign above?

>-    r.set_varying (type);

>-  else

>-    value_range_with_overflow (r, type, new_lb, new_ub);

>+    {

>+      // Make sure that nonzero|X is nonzero.

>+      if (wi::gt_p (lh_lb, 0, sign)

>+	  || wi::gt_p (rh_lb, 0, sign)

>+	  || wi::lt_p (lh_ub, 0, sign)

>+	  || wi::lt_p (rh_ub, 0, sign))

>+	r.set_nonzero (type);

>+      else

>+	r.set_varying (type);

>+      return;

>+    }

>+  value_range_with_overflow (r, type, new_lb, new_ub);

> }

> 

> bool

>@@ -3744,6 +3753,17 @@ range_op_bitwise_and_tests ()

>   i1 = int_range<1> (integer_type_node);

>   op_bitwise_and.op1_range (res, integer_type_node, i1, i2);

>   ASSERT_TRUE (res == int_range<1> (integer_type_node));

>+

>+  // (NONZERO | X) is nonzero.

>+  i1.set_nonzero (integer_type_node);

>+  i2.set_varying (integer_type_node);

>+  op_bitwise_or.fold_range (res, integer_type_node, i1, i2);

>+  ASSERT_TRUE (res.nonzero_p ());

>+

>+  // (NEGATIVE | X) is nonzero.

>+  i1 = int_range<1> (INT (-5), INT (-3));

>+  i2.set_varying (integer_type_node);

>+  op_bitwise_or.fold_range (res, integer_type_node, i1, i2);


Wouldn't you want to assert something here?
thanks,
> }

> 

> void
Martin Sebor via Gcc-patches June 15, 2021, 2:14 p.m. | #2
On 6/15/21 2:39 PM, Bernhard Reutner-Fischer wrote:
> On 15 June 2021 13:48:39 CEST, Aldy Hernandez via Gcc-patches <gcc-patches@gcc.gnu.org> wrote:

>> For bitwise or, nonzero|X is always nonzero.  Make sure we don't drop

>> to

>> varying in this case.

>>

>> This was found while examining differences between VRP/DOM threaders

>> and

>> the upcoming work, but it could be useful for any user of range-ops.

>>

>> Tested on x86-64 Linux.

>>

>> OK?

>>

>> gcc/ChangeLog:

>>

>> 	* range-op.cc (operator_bitwise_or::wi_fold): Make sure

>> 	nonzero|X is nonzero.

>> 	(range_op_bitwise_and_tests): Add tests for above.

>> ---

>> gcc/range-op.cc | 28 ++++++++++++++++++++++++----

>> 1 file changed, 24 insertions(+), 4 deletions(-)

>>

>> diff --git a/gcc/range-op.cc b/gcc/range-op.cc

>> index 742e54686b4..59978466b45 100644

>> --- a/gcc/range-op.cc

>> +++ b/gcc/range-op.cc

>> @@ -2534,11 +2534,20 @@ operator_bitwise_or::wi_fold (irange &r, tree

>> type,

>>      new_lb = wi::max (new_lb, lh_lb, sign);

>>    if (wi::lt_p (rh_ub, 0, sign))

>>      new_lb = wi::max (new_lb, rh_lb, sign);

>> -  // If the limits got swapped around, return varying.

>> +  // If the limits got swapped around, return a conservative range.

>>    if (wi::gt_p (new_lb, new_ub,sign))

> 

> Missing space before sign above?


Fixed.

> 

>> -    r.set_varying (type);

>> -  else

>> -    value_range_with_overflow (r, type, new_lb, new_ub);

>> +    {

>> +      // Make sure that nonzero|X is nonzero.

>> +      if (wi::gt_p (lh_lb, 0, sign)

>> +	  || wi::gt_p (rh_lb, 0, sign)

>> +	  || wi::lt_p (lh_ub, 0, sign)

>> +	  || wi::lt_p (rh_ub, 0, sign))

>> +	r.set_nonzero (type);

>> +      else

>> +	r.set_varying (type);

>> +      return;

>> +    }

>> +  value_range_with_overflow (r, type, new_lb, new_ub);

>> }

>>

>> bool

>> @@ -3744,6 +3753,17 @@ range_op_bitwise_and_tests ()

>>    i1 = int_range<1> (integer_type_node);

>>    op_bitwise_and.op1_range (res, integer_type_node, i1, i2);

>>    ASSERT_TRUE (res == int_range<1> (integer_type_node));

>> +

>> +  // (NONZERO | X) is nonzero.

>> +  i1.set_nonzero (integer_type_node);

>> +  i2.set_varying (integer_type_node);

>> +  op_bitwise_or.fold_range (res, integer_type_node, i1, i2);

>> +  ASSERT_TRUE (res.nonzero_p ());

>> +

>> +  // (NEGATIVE | X) is nonzero.

>> +  i1 = int_range<1> (INT (-5), INT (-3));

>> +  i2.set_varying (integer_type_node);

>> +  op_bitwise_or.fold_range (res, integer_type_node, i1, i2);

> 

> Wouldn't you want to assert something here?


Whoops.  Thanks.

Aldy

For bitwise or, nonzero|X is always nonzero.  Make sure we don't drop to
varying in this case.

gcc/ChangeLog:

	* range-op.cc (operator_bitwise_or::wi_fold): Make sure
	nonzero|X is nonzero.
	(range_op_bitwise_and_tests): Add tests for above.
---
  gcc/range-op.cc | 31 ++++++++++++++++++++++++++-----
  1 file changed, 26 insertions(+), 5 deletions(-)

diff --git a/gcc/range-op.cc b/gcc/range-op.cc
index 742e54686b4..e805f26a333 100644
--- a/gcc/range-op.cc
+++ b/gcc/range-op.cc
@@ -2534,11 +2534,20 @@ operator_bitwise_or::wi_fold (irange &r, tree type,
      new_lb = wi::max (new_lb, lh_lb, sign);
    if (wi::lt_p (rh_ub, 0, sign))
      new_lb = wi::max (new_lb, rh_lb, sign);
-  // If the limits got swapped around, return varying.
-  if (wi::gt_p (new_lb, new_ub,sign))
-    r.set_varying (type);
-  else
-    value_range_with_overflow (r, type, new_lb, new_ub);
+  // If the limits got swapped around, return a conservative range.
+  if (wi::gt_p (new_lb, new_ub, sign))
+    {
+      // Make sure that nonzero|X is nonzero.
+      if (wi::gt_p (lh_lb, 0, sign)
+	  || wi::gt_p (rh_lb, 0, sign)
+	  || wi::lt_p (lh_ub, 0, sign)
+	  || wi::lt_p (rh_ub, 0, sign))
+	r.set_nonzero (type);
+      else
+	r.set_varying (type);
+      return;
+    }
+  value_range_with_overflow (r, type, new_lb, new_ub);
  }

  bool
@@ -3744,6 +3753,18 @@ range_op_bitwise_and_tests ()
    i1 = int_range<1> (integer_type_node);
    op_bitwise_and.op1_range (res, integer_type_node, i1, i2);
    ASSERT_TRUE (res == int_range<1> (integer_type_node));
+
+  // (NONZERO | X) is nonzero.
+  i1.set_nonzero (integer_type_node);
+  i2.set_varying (integer_type_node);
+  op_bitwise_or.fold_range (res, integer_type_node, i1, i2);
+  ASSERT_TRUE (res.nonzero_p ());
+
+  // (NEGATIVE | X) is nonzero.
+  i1 = int_range<1> (INT (-5), INT (-3));
+  i2.set_varying (integer_type_node);
+  op_bitwise_or.fold_range (res, integer_type_node, i1, i2);
+  ASSERT_FALSE (res.contains_p (INT (0)));
  }

  void
-- 
2.31.1
Martin Sebor via Gcc-patches June 15, 2021, 4:33 p.m. | #3
On 6/15/2021 8:14 AM, Aldy Hernandez via Gcc-patches wrote:
>

>

> On 6/15/21 2:39 PM, Bernhard Reutner-Fischer wrote:

>> On 15 June 2021 13:48:39 CEST, Aldy Hernandez via Gcc-patches 

>> <gcc-patches@gcc.gnu.org> wrote:

>>> For bitwise or, nonzero|X is always nonzero.  Make sure we don't drop

>>> to

>>> varying in this case.

>>>

>>> This was found while examining differences between VRP/DOM threaders

>>> and

>>> the upcoming work, but it could be useful for any user of range-ops.

>>>

>>> Tested on x86-64 Linux.

>>>

>>> OK?

>>>

>>> gcc/ChangeLog:

>>>

>>>     * range-op.cc (operator_bitwise_or::wi_fold): Make sure

>>>     nonzero|X is nonzero.

>>>     (range_op_bitwise_and_tests): Add tests for above.

OK
jeff

Patch

diff --git a/gcc/range-op.cc b/gcc/range-op.cc
index 742e54686b4..59978466b45 100644
--- a/gcc/range-op.cc
+++ b/gcc/range-op.cc
@@ -2534,11 +2534,20 @@  operator_bitwise_or::wi_fold (irange &r, tree type,
     new_lb = wi::max (new_lb, lh_lb, sign);
   if (wi::lt_p (rh_ub, 0, sign))
     new_lb = wi::max (new_lb, rh_lb, sign);
-  // If the limits got swapped around, return varying.
+  // If the limits got swapped around, return a conservative range.
   if (wi::gt_p (new_lb, new_ub,sign))
-    r.set_varying (type);
-  else
-    value_range_with_overflow (r, type, new_lb, new_ub);
+    {
+      // Make sure that nonzero|X is nonzero.
+      if (wi::gt_p (lh_lb, 0, sign)
+	  || wi::gt_p (rh_lb, 0, sign)
+	  || wi::lt_p (lh_ub, 0, sign)
+	  || wi::lt_p (rh_ub, 0, sign))
+	r.set_nonzero (type);
+      else
+	r.set_varying (type);
+      return;
+    }
+  value_range_with_overflow (r, type, new_lb, new_ub);
 }
 
 bool
@@ -3744,6 +3753,17 @@  range_op_bitwise_and_tests ()
   i1 = int_range<1> (integer_type_node);
   op_bitwise_and.op1_range (res, integer_type_node, i1, i2);
   ASSERT_TRUE (res == int_range<1> (integer_type_node));
+
+  // (NONZERO | X) is nonzero.
+  i1.set_nonzero (integer_type_node);
+  i2.set_varying (integer_type_node);
+  op_bitwise_or.fold_range (res, integer_type_node, i1, i2);
+  ASSERT_TRUE (res.nonzero_p ());
+
+  // (NEGATIVE | X) is nonzero.
+  i1 = int_range<1> (INT (-5), INT (-3));
+  i2.set_varying (integer_type_node);
+  op_bitwise_or.fold_range (res, integer_type_node, i1, i2);
 }
 
 void