* [patch 3/8 tree-optimization]: Bitwise logic for fold_truth_andor.
@ 2011-07-13 7:34 Kai Tietz
2011-07-13 10:30 ` Richard Guenther
0 siblings, 1 reply; 2+ messages in thread
From: Kai Tietz @ 2011-07-13 7:34 UTC (permalink / raw)
To: GCC Patches; +Cc: Richard Guenther
Hello,
This patch adds support to fold_truth_andor for one-bit precision
typed bitwise-binary and bitwise-not expressions.
ChangeLog
2011-07-13 Kai Tietz <ktietz@redhat.com>
* fold-const.c (fold_truth_andor): Add
support for one-bit bitwise operations.
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:19:22.000000000 +0200
+++ gcc/gcc/fold-const.c 2011-07-13 08:59:14.261620200 +0200
@@ -8248,6 +8248,12 @@ fold_truth_andor (location_t loc, enum t
if (!optimize)
return NULL_TREE;
+ /* If code is BIT_AND_EXPR or BIT_IOR_EXPR, type precision has to be
+ one. Otherwise return NULL_TREE. */
+ if ((code == BIT_AND_EXPR || code == BIT_IOR_EXPR)
+ && (!INTEGRAL_TYPE_P (type) || TYPE_PRECISION (type) != 1))
+ return NULL_TREE;
+
/* Check for things like (A || B) && (A || C). We can convert this
to A || (B && C). Note that either operator can be any of the four
truth and/or operations and the transformation will still be
@@ -8258,7 +8264,9 @@ fold_truth_andor (location_t loc, enum t
&& (TREE_CODE (arg0) == TRUTH_ANDIF_EXPR
|| TREE_CODE (arg0) == TRUTH_ORIF_EXPR
|| TREE_CODE (arg0) == TRUTH_AND_EXPR
- || TREE_CODE (arg0) == TRUTH_OR_EXPR)
+ || TREE_CODE (arg0) == TRUTH_OR_EXPR
+ || TREE_CODE (arg0) == BIT_AND_EXPR
+ || TREE_CODE (arg0) == BIT_IOR_EXPR)
&& ! TREE_SIDE_EFFECTS (TREE_OPERAND (arg0, 1)))
{
tree a00 = TREE_OPERAND (arg0, 0);
@@ -8266,9 +8274,13 @@ fold_truth_andor (location_t loc, enum t
tree a10 = TREE_OPERAND (arg1, 0);
tree a11 = TREE_OPERAND (arg1, 1);
int commutative = ((TREE_CODE (arg0) == TRUTH_OR_EXPR
- || TREE_CODE (arg0) == TRUTH_AND_EXPR)
+ || TREE_CODE (arg0) == TRUTH_AND_EXPR
+ || TREE_CODE (arg0) == BIT_IOR_EXPR
+ || TREE_CODE (arg0) == BIT_AND_EXPR)
&& (code == TRUTH_AND_EXPR
- || code == TRUTH_OR_EXPR));
+ || code == TRUTH_OR_EXPR
+ || code == BIT_AND_EXPR
+ || code == BIT_IOR_EXPR));
if (operand_equal_p (a00, a10, 0))
return fold_build2_loc (loc, TREE_CODE (arg0), type, a00,
@@ -9484,21 +9496,29 @@ fold_binary_loc (location_t loc,
if ((code == BIT_AND_EXPR || code == BIT_IOR_EXPR
|| code == EQ_EXPR || code == NE_EXPR)
- && ((truth_value_p (TREE_CODE (arg0))
- && (truth_value_p (TREE_CODE (arg1))
+ && ((truth_value_type_p (TREE_CODE (arg0), TREE_TYPE (arg0))
+ && (truth_value_type_p (TREE_CODE (arg1), TREE_TYPE (arg1))
|| (TREE_CODE (arg1) == BIT_AND_EXPR
&& integer_onep (TREE_OPERAND (arg1, 1)))))
- || (truth_value_p (TREE_CODE (arg1))
- && (truth_value_p (TREE_CODE (arg0))
+ || (truth_value_type_p (TREE_CODE (arg1), TREE_TYPE (arg1))
+ && (truth_value_type_p (TREE_CODE (arg0), TREE_TYPE (arg0))
|| (TREE_CODE (arg0) == BIT_AND_EXPR
&& integer_onep (TREE_OPERAND (arg0, 1)))))))
{
- tem = fold_build2_loc (loc, code == BIT_AND_EXPR ? TRUTH_AND_EXPR
- : code == BIT_IOR_EXPR ? TRUTH_OR_EXPR
- : TRUTH_XOR_EXPR,
- boolean_type_node,
- fold_convert_loc (loc, boolean_type_node, arg0),
- fold_convert_loc (loc, boolean_type_node, arg1));
+ enum tree_code ncode;
+
+ /* Do we operate on a non-boolified tree? */
+ if (!INTEGRAL_TYPE_P (type) || TYPE_PRECISION (type) != 1)
+ ncode = code == BIT_AND_EXPR ? TRUTH_AND_EXPR
+ : (code == BIT_IOR_EXPR
+ ? TRUTH_OR_EXPR : TRUTH_XOR_EXPR);
+ else
+ ncode = (code == BIT_AND_EXPR || code == BIT_IOR_EXPR) ? code
+ : BIT_XOR_EXPR;
+ tem = fold_build2_loc (loc, ncode,
+ boolean_type_node,
+ fold_convert_loc (loc, boolean_type_node, arg0),
+ fold_convert_loc (loc, boolean_type_node, arg1));
if (code == EQ_EXPR)
tem = invert_truthvalue_loc (loc, tem);
^ permalink raw reply [flat|nested] 2+ messages in thread
* Re: [patch 3/8 tree-optimization]: Bitwise logic for fold_truth_andor.
2011-07-13 7:34 [patch 3/8 tree-optimization]: Bitwise logic for fold_truth_andor Kai Tietz
@ 2011-07-13 10:30 ` Richard Guenther
0 siblings, 0 replies; 2+ messages in thread
From: Richard Guenther @ 2011-07-13 10:30 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_truth_andor for one-bit precision
> typed bitwise-binary and bitwise-not expressions.
Quickly checking some testcases shows we already perform all
the foldings in other places. So please _always_ check for
all transformations you add if there is a testcase that fails before
and passes after your patch.
(A|B)&(A|C) is already folded to (B&C)|A.
Richard.
> ChangeLog
>
> 2011-07-13 Kai Tietz <ktietz@redhat.com>
>
> * fold-const.c (fold_truth_andor): Add
> support for one-bit bitwise operations.
>
> 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:19:22.000000000 +0200
> +++ gcc/gcc/fold-const.c 2011-07-13 08:59:14.261620200 +0200
> @@ -8248,6 +8248,12 @@ fold_truth_andor (location_t loc, enum t
> if (!optimize)
> return NULL_TREE;
>
> + /* If code is BIT_AND_EXPR or BIT_IOR_EXPR, type precision has to be
> + one. Otherwise return NULL_TREE. */
> + if ((code == BIT_AND_EXPR || code == BIT_IOR_EXPR)
> + && (!INTEGRAL_TYPE_P (type) || TYPE_PRECISION (type) != 1))
> + return NULL_TREE;
> +
> /* Check for things like (A || B) && (A || C). We can convert this
> to A || (B && C). Note that either operator can be any of the four
> truth and/or operations and the transformation will still be
> @@ -8258,7 +8264,9 @@ fold_truth_andor (location_t loc, enum t
> && (TREE_CODE (arg0) == TRUTH_ANDIF_EXPR
> || TREE_CODE (arg0) == TRUTH_ORIF_EXPR
> || TREE_CODE (arg0) == TRUTH_AND_EXPR
> - || TREE_CODE (arg0) == TRUTH_OR_EXPR)
> + || TREE_CODE (arg0) == TRUTH_OR_EXPR
> + || TREE_CODE (arg0) == BIT_AND_EXPR
> + || TREE_CODE (arg0) == BIT_IOR_EXPR)
> && ! TREE_SIDE_EFFECTS (TREE_OPERAND (arg0, 1)))
> {
> tree a00 = TREE_OPERAND (arg0, 0);
> @@ -8266,9 +8274,13 @@ fold_truth_andor (location_t loc, enum t
> tree a10 = TREE_OPERAND (arg1, 0);
> tree a11 = TREE_OPERAND (arg1, 1);
> int commutative = ((TREE_CODE (arg0) == TRUTH_OR_EXPR
> - || TREE_CODE (arg0) == TRUTH_AND_EXPR)
> + || TREE_CODE (arg0) == TRUTH_AND_EXPR
> + || TREE_CODE (arg0) == BIT_IOR_EXPR
> + || TREE_CODE (arg0) == BIT_AND_EXPR)
> && (code == TRUTH_AND_EXPR
> - || code == TRUTH_OR_EXPR));
> + || code == TRUTH_OR_EXPR
> + || code == BIT_AND_EXPR
> + || code == BIT_IOR_EXPR));
>
> if (operand_equal_p (a00, a10, 0))
> return fold_build2_loc (loc, TREE_CODE (arg0), type, a00,
> @@ -9484,21 +9496,29 @@ fold_binary_loc (location_t loc,
>
> if ((code == BIT_AND_EXPR || code == BIT_IOR_EXPR
> || code == EQ_EXPR || code == NE_EXPR)
> - && ((truth_value_p (TREE_CODE (arg0))
> - && (truth_value_p (TREE_CODE (arg1))
> + && ((truth_value_type_p (TREE_CODE (arg0), TREE_TYPE (arg0))
> + && (truth_value_type_p (TREE_CODE (arg1), TREE_TYPE (arg1))
> || (TREE_CODE (arg1) == BIT_AND_EXPR
> && integer_onep (TREE_OPERAND (arg1, 1)))))
> - || (truth_value_p (TREE_CODE (arg1))
> - && (truth_value_p (TREE_CODE (arg0))
> + || (truth_value_type_p (TREE_CODE (arg1), TREE_TYPE (arg1))
> + && (truth_value_type_p (TREE_CODE (arg0), TREE_TYPE (arg0))
> || (TREE_CODE (arg0) == BIT_AND_EXPR
> && integer_onep (TREE_OPERAND (arg0, 1)))))))
> {
> - tem = fold_build2_loc (loc, code == BIT_AND_EXPR ? TRUTH_AND_EXPR
> - : code == BIT_IOR_EXPR ? TRUTH_OR_EXPR
> - : TRUTH_XOR_EXPR,
> - boolean_type_node,
> - fold_convert_loc (loc, boolean_type_node, arg0),
> - fold_convert_loc (loc, boolean_type_node, arg1));
> + enum tree_code ncode;
> +
> + /* Do we operate on a non-boolified tree? */
> + if (!INTEGRAL_TYPE_P (type) || TYPE_PRECISION (type) != 1)
> + ncode = code == BIT_AND_EXPR ? TRUTH_AND_EXPR
> + : (code == BIT_IOR_EXPR
> + ? TRUTH_OR_EXPR : TRUTH_XOR_EXPR);
> + else
> + ncode = (code == BIT_AND_EXPR || code == BIT_IOR_EXPR) ? code
> + : BIT_XOR_EXPR;
> + tem = fold_build2_loc (loc, ncode,
> + boolean_type_node,
> + fold_convert_loc (loc, boolean_type_node, arg0),
> + fold_convert_loc (loc, boolean_type_node, arg1));
>
> if (code == EQ_EXPR)
> tem = invert_truthvalue_loc (loc, tem);
>
^ permalink raw reply [flat|nested] 2+ messages in thread
end of thread, other threads:[~2011-07-13 10:26 UTC | newest]
Thread overview: 2+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2011-07-13 7:34 [patch 3/8 tree-optimization]: Bitwise logic for fold_truth_andor Kai Tietz
2011-07-13 10:30 ` 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).