Patchwork [tree-optimization] : Remove dead-code from gimple-fold

login
register
mail settings
Submitter Kai Tietz
Date July 27, 2011, 11:49 a.m.
Message ID <1817334026.290071.1311767391627.JavaMail.root@zmail06.collab.prod.int.phx2.redhat.com>
Download mbox | patch
Permalink /patch/107042/
State New
Headers show

Comments

Kai Tietz - July 27, 2011, 11:49 a.m.
Hello,

this patch removes from gimple-fold the dead-code about TRUTH_AND/TRUTH_OR-expression checks.

ChangeLog

        * gimple-fold.c (or_comparisons_1): Remove TRUTH_AND/OR
        expression handling.
        (and_var_with_comparison_1): Likewise.

Bootstrapped and regression tested on host x86_64-pc-linux-gnu.  Ok for apply?

Regards,
Kai
Richard Guenther - July 27, 2011, 12:44 p.m.
On Wed, Jul 27, 2011 at 1:49 PM, Kai Tietz <ktietz@redhat.com> wrote:
> Hello,
>
> this patch removes from gimple-fold the dead-code about TRUTH_AND/TRUTH_OR-expression checks.
>
> ChangeLog
>
>        * gimple-fold.c (or_comparisons_1): Remove TRUTH_AND/OR
>        expression handling.
>        (and_var_with_comparison_1): Likewise.
>
> Bootstrapped and regression tested on host x86_64-pc-linux-gnu.  Ok for apply?

Ok.

Thanks,
Richard.

> Regards,
> Kai
>
> Index: gcc-head/gcc/gimple-fold.c
> ===================================================================
> --- gcc-head.orig/gcc/gimple-fold.c
> +++ gcc-head/gcc/gimple-fold.c
> @@ -1937,17 +1937,15 @@ and_var_with_comparison_1 (gimple stmt,
>
>   /* If the definition is an AND or OR expression, we may be able to
>      simplify by reassociating.  */
> -  if (innercode == TRUTH_AND_EXPR
> -      || innercode == TRUTH_OR_EXPR
> -      || (TREE_CODE (TREE_TYPE (var)) == BOOLEAN_TYPE
> -         && (innercode == BIT_AND_EXPR || innercode == BIT_IOR_EXPR)))
> +  if (TREE_CODE (TREE_TYPE (var)) == BOOLEAN_TYPE
> +      && (innercode == BIT_AND_EXPR || innercode == BIT_IOR_EXPR))
>     {
>       tree inner1 = gimple_assign_rhs1 (stmt);
>       tree inner2 = gimple_assign_rhs2 (stmt);
>       gimple s;
>       tree t;
>       tree partial = NULL_TREE;
> -      bool is_and = (innercode == TRUTH_AND_EXPR || innercode == BIT_AND_EXPR);
> +      bool is_and = (innercode == BIT_AND_EXPR);
>
>       /* Check for boolean identities that don't require recursive examination
>         of inner1/inner2:
> @@ -2069,6 +2067,7 @@ and_comparisons_1 (enum tree_code code1,
>   if (operand_equal_p (op1a, op2a, 0)
>       && operand_equal_p (op1b, op2b, 0))
>     {
> +      /* Result will be either NULL_TREE, or a combined comparison.  */
>       tree t = combine_comparisons (UNKNOWN_LOCATION,
>                                    TRUTH_ANDIF_EXPR, code1, code2,
>                                    boolean_type_node, op1a, op1b);
> @@ -2080,6 +2079,7 @@ and_comparisons_1 (enum tree_code code1,
>   if (operand_equal_p (op1a, op2b, 0)
>       && operand_equal_p (op1b, op2a, 0))
>     {
> +      /* Result will be either NULL_TREE, or a combined comparison.  */
>       tree t = combine_comparisons (UNKNOWN_LOCATION,
>                                    TRUTH_ANDIF_EXPR, code1,
>                                    swap_tree_comparison (code2),
> @@ -2398,17 +2398,15 @@ or_var_with_comparison_1 (gimple stmt,
>
>   /* If the definition is an AND or OR expression, we may be able to
>      simplify by reassociating.  */
> -  if (innercode == TRUTH_AND_EXPR
> -      || innercode == TRUTH_OR_EXPR
> -      || (TREE_CODE (TREE_TYPE (var)) == BOOLEAN_TYPE
> -         && (innercode == BIT_AND_EXPR || innercode == BIT_IOR_EXPR)))
> +  if (TREE_CODE (TREE_TYPE (var)) == BOOLEAN_TYPE
> +      && (innercode == BIT_AND_EXPR || innercode == BIT_IOR_EXPR))
>     {
>       tree inner1 = gimple_assign_rhs1 (stmt);
>       tree inner2 = gimple_assign_rhs2 (stmt);
>       gimple s;
>       tree t;
>       tree partial = NULL_TREE;
> -      bool is_or = (innercode == TRUTH_OR_EXPR || innercode == BIT_IOR_EXPR);
> +      bool is_or = (innercode == BIT_IOR_EXPR);
>
>       /* Check for boolean identities that don't require recursive examination
>         of inner1/inner2:
> @@ -2531,6 +2529,7 @@ or_comparisons_1 (enum tree_code code1,
>   if (operand_equal_p (op1a, op2a, 0)
>       && operand_equal_p (op1b, op2b, 0))
>     {
> +      /* Result will be either NULL_TREE, or a combined comparison.  */
>       tree t = combine_comparisons (UNKNOWN_LOCATION,
>                                    TRUTH_ORIF_EXPR, code1, code2,
>                                    boolean_type_node, op1a, op1b);
> @@ -2542,6 +2541,7 @@ or_comparisons_1 (enum tree_code code1,
>   if (operand_equal_p (op1a, op2b, 0)
>       && operand_equal_p (op1b, op2a, 0))
>     {
> +      /* Result will be either NULL_TREE, or a combined comparison.  */
>       tree t = combine_comparisons (UNKNOWN_LOCATION,
>                                    TRUTH_ORIF_EXPR, code1,
>                                    swap_tree_comparison (code2),
>

Patch

Index: gcc-head/gcc/gimple-fold.c
===================================================================
--- gcc-head.orig/gcc/gimple-fold.c
+++ gcc-head/gcc/gimple-fold.c
@@ -1937,17 +1937,15 @@  and_var_with_comparison_1 (gimple stmt,
 
   /* If the definition is an AND or OR expression, we may be able to
      simplify by reassociating.  */
-  if (innercode == TRUTH_AND_EXPR
-      || innercode == TRUTH_OR_EXPR
-      || (TREE_CODE (TREE_TYPE (var)) == BOOLEAN_TYPE
-	  && (innercode == BIT_AND_EXPR || innercode == BIT_IOR_EXPR)))
+  if (TREE_CODE (TREE_TYPE (var)) == BOOLEAN_TYPE
+      && (innercode == BIT_AND_EXPR || innercode == BIT_IOR_EXPR))
     {
       tree inner1 = gimple_assign_rhs1 (stmt);
       tree inner2 = gimple_assign_rhs2 (stmt);
       gimple s;
       tree t;
       tree partial = NULL_TREE;
-      bool is_and = (innercode == TRUTH_AND_EXPR || innercode == BIT_AND_EXPR);
+      bool is_and = (innercode == BIT_AND_EXPR);
       
       /* Check for boolean identities that don't require recursive examination
 	 of inner1/inner2:
@@ -2069,6 +2067,7 @@  and_comparisons_1 (enum tree_code code1,
   if (operand_equal_p (op1a, op2a, 0)
       && operand_equal_p (op1b, op2b, 0))
     {
+      /* Result will be either NULL_TREE, or a combined comparison.  */
       tree t = combine_comparisons (UNKNOWN_LOCATION,
 				    TRUTH_ANDIF_EXPR, code1, code2,
 				    boolean_type_node, op1a, op1b);
@@ -2080,6 +2079,7 @@  and_comparisons_1 (enum tree_code code1,
   if (operand_equal_p (op1a, op2b, 0)
       && operand_equal_p (op1b, op2a, 0))
     {
+      /* Result will be either NULL_TREE, or a combined comparison.  */
       tree t = combine_comparisons (UNKNOWN_LOCATION,
 				    TRUTH_ANDIF_EXPR, code1,
 				    swap_tree_comparison (code2),
@@ -2398,17 +2398,15 @@  or_var_with_comparison_1 (gimple stmt,
   
   /* If the definition is an AND or OR expression, we may be able to
      simplify by reassociating.  */
-  if (innercode == TRUTH_AND_EXPR
-      || innercode == TRUTH_OR_EXPR
-      || (TREE_CODE (TREE_TYPE (var)) == BOOLEAN_TYPE
-	  && (innercode == BIT_AND_EXPR || innercode == BIT_IOR_EXPR)))
+  if (TREE_CODE (TREE_TYPE (var)) == BOOLEAN_TYPE
+      && (innercode == BIT_AND_EXPR || innercode == BIT_IOR_EXPR))
     {
       tree inner1 = gimple_assign_rhs1 (stmt);
       tree inner2 = gimple_assign_rhs2 (stmt);
       gimple s;
       tree t;
       tree partial = NULL_TREE;
-      bool is_or = (innercode == TRUTH_OR_EXPR || innercode == BIT_IOR_EXPR);
+      bool is_or = (innercode == BIT_IOR_EXPR);
       
       /* Check for boolean identities that don't require recursive examination
 	 of inner1/inner2:
@@ -2531,6 +2529,7 @@  or_comparisons_1 (enum tree_code code1, 
   if (operand_equal_p (op1a, op2a, 0)
       && operand_equal_p (op1b, op2b, 0))
     {
+      /* Result will be either NULL_TREE, or a combined comparison.  */
       tree t = combine_comparisons (UNKNOWN_LOCATION,
 				    TRUTH_ORIF_EXPR, code1, code2,
 				    boolean_type_node, op1a, op1b);
@@ -2542,6 +2541,7 @@  or_comparisons_1 (enum tree_code code1, 
   if (operand_equal_p (op1a, op2b, 0)
       && operand_equal_p (op1b, op2a, 0))
     {
+      /* Result will be either NULL_TREE, or a combined comparison.  */
       tree t = combine_comparisons (UNKNOWN_LOCATION,
 				    TRUTH_ORIF_EXPR, code1,
 				    swap_tree_comparison (code2),