* [patch 4/8 tree-optimization]: Bitwise or logic for fold_binary_loc.
@ 2011-07-13 7:35 Kai Tietz
2011-07-13 10:31 ` Richard Guenther
0 siblings, 1 reply; 4+ messages in thread
From: Kai Tietz @ 2011-07-13 7:35 UTC (permalink / raw)
To: GCC Patches; +Cc: Richard Guenther
Hello,
This patch adds support to fold_binary_loc for one-bit precision
typed bitwise-or expression.
ChangeLog
2011-07-13 Kai Tietz <ktietz@redhat.com>
* fold-const.c (fold_binary_loc): Add
support for one-bit bitwise-or optimizeation.
Bootstrapped and regression tested with prior patches of this series
for x86_64-pc-linux-gnu.
Ok for apply?
Regards,
Kai
Index: gcc/gcc/fold-const.c
===================================================================
--- gcc.orig/gcc/fold-const.c 2011-07-13 08:23:29.000000000 +0200
+++ gcc/gcc/fold-const.c 2011-07-13 08:59:04.011620200 +0200
@@ -10688,6 +10688,52 @@ fold_binary_loc (location_t loc,
return omit_one_operand_loc (loc, type, t1, arg0);
}
+ if (TYPE_PRECISION (type) == 1 && INTEGRAL_TYPE_P (type))
+ {
+ /* If arg0 is constant zero, drop it. */
+ if (TREE_CODE (arg0) == INTEGER_CST && integer_zerop (arg0))
+ return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg1));
+ if (TREE_CODE (arg0) == INTEGER_CST && ! integer_zerop (arg0))
+ return omit_one_operand_loc (loc, type, arg0, arg1);
+
+ /* !X | X is always true. ~X | X is always true. */
+ if ((TREE_CODE (arg0) == TRUTH_NOT_EXPR
+ || TREE_CODE (arg0) == BIT_NOT_EXPR)
+ && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
+ return omit_one_operand_loc (loc, type, integer_one_node, arg1);
+ /* X | !X is always true. X | ~X is always true. */
+ if ((TREE_CODE (arg1) == TRUTH_NOT_EXPR
+ || TREE_CODE (arg1) == BIT_NOT_EXPR)
+ && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
+ return omit_one_operand_loc (loc, type, integer_one_node, arg0);
+
+ /* (X & !Y) | (!X & Y) is X ^ Y */
+ if (TREE_CODE (arg0) == BIT_AND_EXPR
+ && TREE_CODE (arg1) == BIT_AND_EXPR)
+ {
+ tree a0, a1, l0, l1, n0, n1;
+
+ a0 = fold_convert_loc (loc, type, TREE_OPERAND (arg1, 0));
+ a1 = fold_convert_loc (loc, type, TREE_OPERAND (arg1, 1));
+
+ l0 = fold_convert_loc (loc, type, TREE_OPERAND (arg0, 0));
+ l1 = fold_convert_loc (loc, type, TREE_OPERAND (arg0, 1));
+
+ n0 = fold_build1_loc (loc, TRUTH_NOT_EXPR, type, l0);
+ n1 = fold_build1_loc (loc, TRUTH_NOT_EXPR, type, l1);
+
+ if ((operand_equal_p (n0, a0, 0)
+ && operand_equal_p (n1, a1, 0))
+ || (operand_equal_p (n0, a1, 0)
+ && operand_equal_p (n1, a0, 0)))
+ return fold_build2_loc (loc, BIT_XOR_EXPR, type, l0, n1);
+ }
+
+ tem = fold_truth_andor (loc, code, type, arg0, arg1, op0, op1);
+ if (tem)
+ return tem;
+ }
+
/* Canonicalize (X & C1) | C2. */
if (TREE_CODE (arg0) == BIT_AND_EXPR
&& TREE_CODE (arg1) == INTEGER_CST
^ permalink raw reply [flat|nested] 4+ messages in thread* Re: [patch 4/8 tree-optimization]: Bitwise or logic for fold_binary_loc.
2011-07-13 7:35 [patch 4/8 tree-optimization]: Bitwise or logic for fold_binary_loc Kai Tietz
@ 2011-07-13 10:31 ` Richard Guenther
2011-07-13 10:48 ` Kai Tietz
0 siblings, 1 reply; 4+ messages in thread
From: Richard Guenther @ 2011-07-13 10:31 UTC (permalink / raw)
To: Kai Tietz; +Cc: GCC Patches
On Wed, Jul 13, 2011 at 9:33 AM, Kai Tietz <ktietz70@googlemail.com> wrote:
> Hello,
>
> This patch adds support to fold_binary_loc for one-bit precision
> typed bitwise-or expression.
Seems to be a fallout of the missing TRUTH_NOT conversion as well.
> ChangeLog
>
> 2011-07-13 Kai Tietz <ktietz@redhat.com>
>
> * fold-const.c (fold_binary_loc): Add
> support for one-bit bitwise-or optimizeation.
>
> Bootstrapped and regression tested with prior patches of this series
> for x86_64-pc-linux-gnu.
> Ok for apply?
>
> Regards,
> Kai
>
> Index: gcc/gcc/fold-const.c
> ===================================================================
> --- gcc.orig/gcc/fold-const.c 2011-07-13 08:23:29.000000000 +0200
> +++ gcc/gcc/fold-const.c 2011-07-13 08:59:04.011620200 +0200
> @@ -10688,6 +10688,52 @@ fold_binary_loc (location_t loc,
> return omit_one_operand_loc (loc, type, t1, arg0);
> }
>
> + if (TYPE_PRECISION (type) == 1 && INTEGRAL_TYPE_P (type))
> + {
> + /* If arg0 is constant zero, drop it. */
> + if (TREE_CODE (arg0) == INTEGER_CST && integer_zerop (arg0))
> + return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg1));
> + if (TREE_CODE (arg0) == INTEGER_CST && ! integer_zerop (arg0))
> + return omit_one_operand_loc (loc, type, arg0, arg1);
> +
> + /* !X | X is always true. ~X | X is always true. */
> + if ((TREE_CODE (arg0) == TRUTH_NOT_EXPR
> + || TREE_CODE (arg0) == BIT_NOT_EXPR)
> + && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
> + return omit_one_operand_loc (loc, type, integer_one_node, arg1);
> + /* X | !X is always true. X | ~X is always true. */
> + if ((TREE_CODE (arg1) == TRUTH_NOT_EXPR
> + || TREE_CODE (arg1) == BIT_NOT_EXPR)
> + && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
> + return omit_one_operand_loc (loc, type, integer_one_node, arg0);
> +
> + /* (X & !Y) | (!X & Y) is X ^ Y */
> + if (TREE_CODE (arg0) == BIT_AND_EXPR
> + && TREE_CODE (arg1) == BIT_AND_EXPR)
> + {
> + tree a0, a1, l0, l1, n0, n1;
> +
> + a0 = fold_convert_loc (loc, type, TREE_OPERAND (arg1, 0));
> + a1 = fold_convert_loc (loc, type, TREE_OPERAND (arg1, 1));
> +
> + l0 = fold_convert_loc (loc, type, TREE_OPERAND (arg0, 0));
> + l1 = fold_convert_loc (loc, type, TREE_OPERAND (arg0, 1));
> +
> + n0 = fold_build1_loc (loc, TRUTH_NOT_EXPR, type, l0);
> + n1 = fold_build1_loc (loc, TRUTH_NOT_EXPR, type, l1);
> +
> + if ((operand_equal_p (n0, a0, 0)
> + && operand_equal_p (n1, a1, 0))
> + || (operand_equal_p (n0, a1, 0)
> + && operand_equal_p (n1, a0, 0)))
> + return fold_build2_loc (loc, BIT_XOR_EXPR, type, l0, n1);
> + }
> +
> + tem = fold_truth_andor (loc, code, type, arg0, arg1, op0, op1);
> + if (tem)
> + return tem;
> + }
> +
> /* Canonicalize (X & C1) | C2. */
> if (TREE_CODE (arg0) == BIT_AND_EXPR
> && TREE_CODE (arg1) == INTEGER_CST
>
^ permalink raw reply [flat|nested] 4+ messages in thread* Re: [patch 4/8 tree-optimization]: Bitwise or logic for fold_binary_loc.
2011-07-13 10:31 ` Richard Guenther
@ 2011-07-13 10:48 ` Kai Tietz
2011-07-13 11:09 ` Richard Guenther
0 siblings, 1 reply; 4+ messages in thread
From: Kai Tietz @ 2011-07-13 10:48 UTC (permalink / raw)
To: Richard Guenther; +Cc: GCC Patches
2011/7/13 Richard Guenther <richard.guenther@gmail.com>:
> On Wed, Jul 13, 2011 at 9:33 AM, Kai Tietz <ktietz70@googlemail.com> wrote:
>> Hello,
>>
>> This patch adds support to fold_binary_loc for one-bit precision
>> typed bitwise-or expression.
>
> Seems to be a fallout of the missing TRUTH_NOT conversion as well.
>
>> ChangeLog
>>
>> 2011-07-13 Kai Tietz <ktietz@redhat.com>
>>
>> * fold-const.c (fold_binary_loc): Add
>> support for one-bit bitwise-or optimizeation.
>>
>> Bootstrapped and regression tested with prior patches of this series
>> for x86_64-pc-linux-gnu.
>> Ok for apply?
>>
>> Regards,
>> Kai
>>
>> Index: gcc/gcc/fold-const.c
>> ===================================================================
>> --- gcc.orig/gcc/fold-const.c 2011-07-13 08:23:29.000000000 +0200
>> +++ gcc/gcc/fold-const.c 2011-07-13 08:59:04.011620200 +0200
>> @@ -10688,6 +10688,52 @@ fold_binary_loc (location_t loc,
>> return omit_one_operand_loc (loc, type, t1, arg0);
>> }
>>
>> + if (TYPE_PRECISION (type) == 1 && INTEGRAL_TYPE_P (type))
>> + {
>> + /* If arg0 is constant zero, drop it. */
>> + if (TREE_CODE (arg0) == INTEGER_CST && integer_zerop (arg0))
>> + return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg1));
>> + if (TREE_CODE (arg0) == INTEGER_CST && ! integer_zerop (arg0))
>> + return omit_one_operand_loc (loc, type, arg0, arg1);
>> +
>> + /* !X | X is always true. ~X | X is always true. */
>> + if ((TREE_CODE (arg0) == TRUTH_NOT_EXPR
>> + || TREE_CODE (arg0) == BIT_NOT_EXPR)
>> + && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
>> + return omit_one_operand_loc (loc, type, integer_one_node, arg1);
>> + /* X | !X is always true. X | ~X is always true. */
>> + if ((TREE_CODE (arg1) == TRUTH_NOT_EXPR
>> + || TREE_CODE (arg1) == BIT_NOT_EXPR)
>> + && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
>> + return omit_one_operand_loc (loc, type, integer_one_node, arg0);
>> +
>> + /* (X & !Y) | (!X & Y) is X ^ Y */
>> + if (TREE_CODE (arg0) == BIT_AND_EXPR
>> + && TREE_CODE (arg1) == BIT_AND_EXPR)
>> + {
>> + tree a0, a1, l0, l1, n0, n1;
>> +
>> + a0 = fold_convert_loc (loc, type, TREE_OPERAND (arg1, 0));
>> + a1 = fold_convert_loc (loc, type, TREE_OPERAND (arg1, 1));
>> +
>> + l0 = fold_convert_loc (loc, type, TREE_OPERAND (arg0, 0));
>> + l1 = fold_convert_loc (loc, type, TREE_OPERAND (arg0, 1));
>> +
>> + n0 = fold_build1_loc (loc, TRUTH_NOT_EXPR, type, l0);
>> + n1 = fold_build1_loc (loc, TRUTH_NOT_EXPR, type, l1);
>> +
>> + if ((operand_equal_p (n0, a0, 0)
>> + && operand_equal_p (n1, a1, 0))
>> + || (operand_equal_p (n0, a1, 0)
>> + && operand_equal_p (n1, a0, 0)))
>> + return fold_build2_loc (loc, BIT_XOR_EXPR, type, l0, n1);
>> + }
>> +
>> + tem = fold_truth_andor (loc, code, type, arg0, arg1, op0, op1);
>> + if (tem)
>> + return tem;
>> + }
>> +
>> /* Canonicalize (X & C1) | C2. */
>> if (TREE_CODE (arg0) == BIT_AND_EXPR
>> && TREE_CODE (arg1) == INTEGER_CST
Well, I wouldn't call it fallout. As by this we are able to handle
things like ~(X >= B) and see that it can be converted to X < B. The
point here is that we avoid that fold re-introduces here the TRUTH
variants for the bitwise ones (for sure some parts are redudant and
might be something to be factored out like we did for truth_andor
function). Also we catch by this patterns like ~X op ~Y and convert
them to ~(X op Y), which is just valid for one-bit precision typed X
and Y.
As in general !x is not the same as ~x, beside x has one-bit precision
integeral type.
I will adjust patches so, that for one-bit precision type we alway
use here instead BIT_NOT_EXPR (instead of TRUTH_NOT). This is
reasonable.
^ permalink raw reply [flat|nested] 4+ messages in thread* Re: [patch 4/8 tree-optimization]: Bitwise or logic for fold_binary_loc.
2011-07-13 10:48 ` Kai Tietz
@ 2011-07-13 11:09 ` Richard Guenther
0 siblings, 0 replies; 4+ messages in thread
From: Richard Guenther @ 2011-07-13 11:09 UTC (permalink / raw)
To: Kai Tietz; +Cc: GCC Patches
On Wed, Jul 13, 2011 at 12:39 PM, Kai Tietz <ktietz70@googlemail.com> wrote:
> 2011/7/13 Richard Guenther <richard.guenther@gmail.com>:
>> On Wed, Jul 13, 2011 at 9:33 AM, Kai Tietz <ktietz70@googlemail.com> wrote:
>>> Hello,
>>>
>>> This patch adds support to fold_binary_loc for one-bit precision
>>> typed bitwise-or expression.
>>
>> Seems to be a fallout of the missing TRUTH_NOT conversion as well.
>>
>>> ChangeLog
>>>
>>> 2011-07-13 Kai Tietz <ktietz@redhat.com>
>>>
>>> * fold-const.c (fold_binary_loc): Add
>>> support for one-bit bitwise-or optimizeation.
>>>
>>> Bootstrapped and regression tested with prior patches of this series
>>> for x86_64-pc-linux-gnu.
>>> Ok for apply?
>>>
>>> Regards,
>>> Kai
>>>
>>> Index: gcc/gcc/fold-const.c
>>> ===================================================================
>>> --- gcc.orig/gcc/fold-const.c 2011-07-13 08:23:29.000000000 +0200
>>> +++ gcc/gcc/fold-const.c 2011-07-13 08:59:04.011620200 +0200
>>> @@ -10688,6 +10688,52 @@ fold_binary_loc (location_t loc,
>>> return omit_one_operand_loc (loc, type, t1, arg0);
>>> }
>>>
>>> + if (TYPE_PRECISION (type) == 1 && INTEGRAL_TYPE_P (type))
>>> + {
>>> + /* If arg0 is constant zero, drop it. */
>>> + if (TREE_CODE (arg0) == INTEGER_CST && integer_zerop (arg0))
>>> + return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg1));
>>> + if (TREE_CODE (arg0) == INTEGER_CST && ! integer_zerop (arg0))
>>> + return omit_one_operand_loc (loc, type, arg0, arg1);
>>> +
>>> + /* !X | X is always true. ~X | X is always true. */
>>> + if ((TREE_CODE (arg0) == TRUTH_NOT_EXPR
>>> + || TREE_CODE (arg0) == BIT_NOT_EXPR)
>>> + && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
>>> + return omit_one_operand_loc (loc, type, integer_one_node, arg1);
>>> + /* X | !X is always true. X | ~X is always true. */
>>> + if ((TREE_CODE (arg1) == TRUTH_NOT_EXPR
>>> + || TREE_CODE (arg1) == BIT_NOT_EXPR)
>>> + && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
>>> + return omit_one_operand_loc (loc, type, integer_one_node, arg0);
>>> +
>>> + /* (X & !Y) | (!X & Y) is X ^ Y */
>>> + if (TREE_CODE (arg0) == BIT_AND_EXPR
>>> + && TREE_CODE (arg1) == BIT_AND_EXPR)
>>> + {
>>> + tree a0, a1, l0, l1, n0, n1;
>>> +
>>> + a0 = fold_convert_loc (loc, type, TREE_OPERAND (arg1, 0));
>>> + a1 = fold_convert_loc (loc, type, TREE_OPERAND (arg1, 1));
>>> +
>>> + l0 = fold_convert_loc (loc, type, TREE_OPERAND (arg0, 0));
>>> + l1 = fold_convert_loc (loc, type, TREE_OPERAND (arg0, 1));
>>> +
>>> + n0 = fold_build1_loc (loc, TRUTH_NOT_EXPR, type, l0);
>>> + n1 = fold_build1_loc (loc, TRUTH_NOT_EXPR, type, l1);
>>> +
>>> + if ((operand_equal_p (n0, a0, 0)
>>> + && operand_equal_p (n1, a1, 0))
>>> + || (operand_equal_p (n0, a1, 0)
>>> + && operand_equal_p (n1, a0, 0)))
>>> + return fold_build2_loc (loc, BIT_XOR_EXPR, type, l0, n1);
>>> + }
>>> +
>>> + tem = fold_truth_andor (loc, code, type, arg0, arg1, op0, op1);
>>> + if (tem)
>>> + return tem;
>>> + }
>>> +
>>> /* Canonicalize (X & C1) | C2. */
>>> if (TREE_CODE (arg0) == BIT_AND_EXPR
>>> && TREE_CODE (arg1) == INTEGER_CST
>
> Well, I wouldn't call it fallout. As by this we are able to handle
> things like ~(X >= B) and see that it can be converted to X < B. The
> point here is that we avoid that fold re-introduces here the TRUTH
> variants for the bitwise ones (for sure some parts are redudant and
> might be something to be factored out like we did for truth_andor
> function). Also we catch by this patterns like ~X op ~Y and convert
> them to ~(X op Y), which is just valid for one-bit precision typed X
> and Y.
> As in general !x is not the same as ~x, beside x has one-bit precision
> integeral type.
>
> I will adjust patches so, that for one-bit precision type we alway
> use here instead BIT_NOT_EXPR (instead of TRUTH_NOT). This is
> reasonable.
Sorry, but no.
fold-const.c should not look at 1-bitness at all. fold-const.c should
special-case BOOLEAN_TYPEs - and it does that already.
This patch series makes me think that it is premature given that
on gimple we still mix TRUTH_NOT_EXPR and BIT_*_EXPRs.
Richard.
^ permalink raw reply [flat|nested] 4+ messages in thread
end of thread, other threads:[~2011-07-13 11:03 UTC | newest]
Thread overview: 4+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2011-07-13 7:35 [patch 4/8 tree-optimization]: Bitwise or logic for fold_binary_loc Kai Tietz
2011-07-13 10:31 ` Richard Guenther
2011-07-13 10:48 ` Kai Tietz
2011-07-13 11:09 ` Richard Guenther
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).