From 7f3ff782991c13d787b67918e965c8a1dd620935 Mon Sep 17 00:00:00 2001 From: Kai Tietz Date: Thu, 21 Jul 2011 14:11:28 +0200 Subject: [PATCH] ChangeLog gcc/ 2011-07-21 Kai Tietz * fold-const.c (fold_unary_loc): Preserve indirect comparison cast to none-boolean type. * tree-ssa.c (useless_type_conversion_p): Preserve cast from/to boolean-type. * gimplify.c (gimple_boolify): Handle boolification of comparisons. (gimplify_expr): Boolifiy non aggregate-typed comparisons. * tree-cfg.c (verify_gimple_comparison): Check result type of comparison expression. * tree-ssa-forwprop.c (forward_propagate_comparison): Adjust test of condition result and disallow type-cast sinking into comparison. ChangeLog gcc/testsuite 2011-07-21 Kai Tietz * gcc.dg/tree-ssa/pr30978.c: adjusted. * gcc.dg/tree-ssa/ssa-fre-6.c: Likewise. * gcc.dg/binop-xor1.c: Set to fail. * gcc.dg/binop-xor3.c: Set to fail. From-SVN: r176563 --- gcc/ChangeLog | 16 +++++++++++++ gcc/fold-const.c | 4 ++-- gcc/gimplify.c | 29 ++++++++++++++++++----- gcc/testsuite/ChangeLog | 5 ++++ gcc/testsuite/gcc.dg/binop-xor1.c | 5 +--- gcc/testsuite/gcc.dg/binop-xor3.c | 5 +--- gcc/testsuite/gcc.dg/tree-ssa/pr30978.c | 5 +++- gcc/testsuite/gcc.dg/tree-ssa/ssa-fre-6.c | 2 +- gcc/tree-cfg.c | 4 +++- gcc/tree-ssa-forwprop.c | 19 ++++++--------- gcc/tree-ssa.c | 8 +++---- 11 files changed, 67 insertions(+), 35 deletions(-) diff --git a/gcc/ChangeLog b/gcc/ChangeLog index 9f26c891f6b..44f962adee0 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,19 @@ +2011-07-21 Kai Tietz + + * fold-const.c (fold_unary_loc): Preserve indirect + comparison cast to none-boolean type. + * tree-ssa.c (useless_type_conversion_p): Preserve cast + from/to boolean-type. + * gimplify.c (gimple_boolify): Handle boolification + of comparisons. + (gimplify_expr): Boolifiy non aggregate-typed + comparisons. + * tree-cfg.c (verify_gimple_comparison): Check result + type of comparison expression. + * tree-ssa-forwprop.c (forward_propagate_comparison): + Adjust test of condition result and disallow type-cast + sinking into comparison. + 2011-07-21 Richard Guenther * tree-ssa-forwprop.c (combine_conversions): Return whether diff --git a/gcc/fold-const.c b/gcc/fold-const.c index c5539bf4616..889a92c71f8 100644 --- a/gcc/fold-const.c +++ b/gcc/fold-const.c @@ -7664,11 +7664,11 @@ fold_unary_loc (location_t loc, enum tree_code code, tree type, tree op0) non-integral type. Do not fold the result as that would not simplify further, also folding again results in recursions. */ - if (INTEGRAL_TYPE_P (type)) + if (TREE_CODE (type) == BOOLEAN_TYPE) return build2_loc (loc, TREE_CODE (op0), type, TREE_OPERAND (op0, 0), TREE_OPERAND (op0, 1)); - else + else if (!INTEGRAL_TYPE_P (type)) return build3_loc (loc, COND_EXPR, type, op0, fold_convert (type, boolean_true_node), fold_convert (type, boolean_false_node)); diff --git a/gcc/gimplify.c b/gcc/gimplify.c index 03e2ca622cb..af9cdd7c848 100644 --- a/gcc/gimplify.c +++ b/gcc/gimplify.c @@ -2860,18 +2860,23 @@ gimple_boolify (tree expr) case TRUTH_NOT_EXPR: TREE_OPERAND (expr, 0) = gimple_boolify (TREE_OPERAND (expr, 0)); - /* FALLTHRU */ - case EQ_EXPR: case NE_EXPR: - case LE_EXPR: case GE_EXPR: case LT_EXPR: case GT_EXPR: /* These expressions always produce boolean results. */ - TREE_TYPE (expr) = boolean_type_node; + if (TREE_CODE (type) != BOOLEAN_TYPE) + TREE_TYPE (expr) = boolean_type_node; return expr; default: + if (COMPARISON_CLASS_P (expr)) + { + /* There expressions always prduce boolean results. */ + if (TREE_CODE (type) != BOOLEAN_TYPE) + TREE_TYPE (expr) = boolean_type_node; + return expr; + } /* Other expressions that get here must have boolean values, but might need to be converted to the appropriate mode. */ - if (type == boolean_type_node) + if (TREE_CODE (type) == BOOLEAN_TYPE) return expr; return fold_convert_loc (loc, boolean_type_node, expr); } @@ -7316,7 +7321,19 @@ gimplify_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p, tree type = TREE_TYPE (TREE_OPERAND (*expr_p, 1)); if (!AGGREGATE_TYPE_P (type)) - goto expr_2; + { + tree org_type = TREE_TYPE (*expr_p); + *expr_p = gimple_boolify (*expr_p); + if (!useless_type_conversion_p (org_type, + TREE_TYPE (*expr_p))) + { + *expr_p = fold_convert_loc (input_location, + org_type, *expr_p); + ret = GS_OK; + } + else + goto expr_2; + } else if (TYPE_MODE (type) != BLKmode) ret = gimplify_scalar_mode_aggregate_compare (expr_p); else diff --git a/gcc/testsuite/ChangeLog b/gcc/testsuite/ChangeLog index d0df27b5413..05ad509b33a 100644 --- a/gcc/testsuite/ChangeLog +++ b/gcc/testsuite/ChangeLog @@ -1,3 +1,8 @@ +2011-07-21 Kai Tietz + + * gcc.dg/tree-ssa/pr30978.c: adjusted. + * gcc.dg/tree-ssa/ssa-fre-6.c: Likewise. + 2011-07-21 Tobias Burnus * gfortran.dg/coarray_lib_token_1.f90: New. diff --git a/gcc/testsuite/gcc.dg/binop-xor1.c b/gcc/testsuite/gcc.dg/binop-xor1.c index 53a2ce23ab3..48f6b425959 100644 --- a/gcc/testsuite/gcc.dg/binop-xor1.c +++ b/gcc/testsuite/gcc.dg/binop-xor1.c @@ -7,8 +7,5 @@ foo (int a, int b, int c) return ((a && !b && c) || (!a && b && c)); } -/* We expect to see ""; confirm that, so that we know to count - it in the real test. */ -/* { dg-final { scan-tree-dump-times "\]*>" 5 "optimized" } } */ -/* { dg-final { scan-tree-dump-times "\\\^" 1 "optimized" } } */ +/* { dg-final { scan-tree-dump-times "\\\^" 1 "optimized" { xfail *-*-* } } } */ /* { dg-final { cleanup-tree-dump "optimized" } } */ diff --git a/gcc/testsuite/gcc.dg/binop-xor3.c b/gcc/testsuite/gcc.dg/binop-xor3.c index 97c7888189a..9d3b50bd4ee 100644 --- a/gcc/testsuite/gcc.dg/binop-xor3.c +++ b/gcc/testsuite/gcc.dg/binop-xor3.c @@ -7,8 +7,5 @@ foo (int a, int b) return ((a && !b) || (!a && b)); } -/* We expect to see ""; confirm that, so that we know to count - it in the real test. */ -/* { dg-final { scan-tree-dump-times "\]*>" 1 "optimized" } } */ -/* { dg-final { scan-tree-dump-times "\\\^" 1 "optimized" } } */ +/* { dg-final { scan-tree-dump-times "\\\^" 1 "optimized" { xfail *-*-* } } } */ /* { dg-final { cleanup-tree-dump "optimized" } } */ diff --git a/gcc/testsuite/gcc.dg/tree-ssa/pr30978.c b/gcc/testsuite/gcc.dg/tree-ssa/pr30978.c index 3329383cbe8..ee45e5b4fe8 100644 --- a/gcc/testsuite/gcc.dg/tree-ssa/pr30978.c +++ b/gcc/testsuite/gcc.dg/tree-ssa/pr30978.c @@ -10,5 +10,8 @@ int foo(int a) return e; } -/* { dg-final { scan-tree-dump "e_. = a_..D. > 0;" "optimized" } } */ +/* { dg-final { scan-tree-dump-times " = " 2 "optimized" } } */ +/* One comparison and one extension to int. */ +/* { dg-final { scan-tree-dump " = a_..D. > 0;" "optimized" } } */ +/* { dg-final { scan-tree-dump "e_. = \\\(int\\\)" "optimized" } } */ /* { dg-final { cleanup-tree-dump "optimized" } } */ diff --git a/gcc/testsuite/gcc.dg/tree-ssa/ssa-fre-6.c b/gcc/testsuite/gcc.dg/tree-ssa/ssa-fre-6.c index 65883cd14bd..18a9d9b895a 100644 --- a/gcc/testsuite/gcc.dg/tree-ssa/ssa-fre-6.c +++ b/gcc/testsuite/gcc.dg/tree-ssa/ssa-fre-6.c @@ -2,5 +2,5 @@ /* { dg-options "-O -fdump-tree-fre1-details" } */ int i; int foo(void) { i = 2; int j = i * 2; int k = i + 2; return j == k; } -/* { dg-final { scan-tree-dump-times "Replaced " 5 "fre1" } } */ +/* { dg-final { scan-tree-dump-times "Replaced " 6 "fre1" } } */ /* { dg-final { cleanup-tree-dump "fre1" } } */ diff --git a/gcc/tree-cfg.c b/gcc/tree-cfg.c index cd134728bb7..bc71dd60fa1 100644 --- a/gcc/tree-cfg.c +++ b/gcc/tree-cfg.c @@ -3203,7 +3203,9 @@ verify_gimple_comparison (tree type, tree op0, tree op1) && (!POINTER_TYPE_P (op0_type) || !POINTER_TYPE_P (op1_type) || TYPE_MODE (op0_type) != TYPE_MODE (op1_type))) - || !INTEGRAL_TYPE_P (type)) + || !INTEGRAL_TYPE_P (type) + || (TREE_CODE (type) != BOOLEAN_TYPE + && TYPE_PRECISION (type) != 1)) { error ("type mismatch in comparison expression"); debug_generic_expr (type); diff --git a/gcc/tree-ssa-forwprop.c b/gcc/tree-ssa-forwprop.c index d51773a2a3f..c08cb18e7af 100644 --- a/gcc/tree-ssa-forwprop.c +++ b/gcc/tree-ssa-forwprop.c @@ -1132,20 +1132,12 @@ forward_propagate_comparison (gimple stmt) if (!INTEGRAL_TYPE_P (TREE_TYPE (lhs))) return false; - /* We can propagate the condition into a conversion. */ - if (CONVERT_EXPR_CODE_P (code)) - { - /* Avoid using fold here as that may create a COND_EXPR with - non-boolean condition as canonical form. */ - tmp = build2 (gimple_assign_rhs_code (stmt), TREE_TYPE (lhs), - gimple_assign_rhs1 (stmt), gimple_assign_rhs2 (stmt)); - } /* We can propagate the condition into a statement that computes the logical negation of the comparison result. */ - else if ((code == BIT_NOT_EXPR - && TYPE_PRECISION (TREE_TYPE (lhs)) == 1) - || (code == BIT_XOR_EXPR - && integer_onep (gimple_assign_rhs2 (use_stmt)))) + if ((code == BIT_NOT_EXPR + && TYPE_PRECISION (TREE_TYPE (lhs)) == 1) + || (code == BIT_XOR_EXPR + && integer_onep (gimple_assign_rhs2 (use_stmt)))) { tree type = TREE_TYPE (gimple_assign_rhs1 (stmt)); bool nans = HONOR_NANS (TYPE_MODE (type)); @@ -1750,6 +1742,7 @@ simplify_bitwise_binary (gimple_stmt_iterator *gsi) arg2)); tem = make_ssa_name (tem, newop); gimple_assign_set_lhs (newop, tem); + gimple_set_location (newop, gimple_location (stmt)); gsi_insert_before (gsi, newop, GSI_SAME_STMT); gimple_assign_set_rhs_with_ops_1 (gsi, NOP_EXPR, tem, NULL_TREE, NULL_TREE); @@ -1779,6 +1772,7 @@ simplify_bitwise_binary (gimple_stmt_iterator *gsi) newop = gimple_build_assign_with_ops (code, tem, def1_arg1, def2_arg1); tem = make_ssa_name (tem, newop); gimple_assign_set_lhs (newop, tem); + gimple_set_location (newop, gimple_location (stmt)); gsi_insert_before (gsi, newop, GSI_SAME_STMT); gimple_assign_set_rhs_with_ops_1 (gsi, NOP_EXPR, tem, NULL_TREE, NULL_TREE); @@ -1807,6 +1801,7 @@ simplify_bitwise_binary (gimple_stmt_iterator *gsi) tem, def1_arg1, arg2); tem = make_ssa_name (tem, newop); gimple_assign_set_lhs (newop, tem); + gimple_set_location (newop, gimple_location (stmt)); /* Make sure to re-process the new stmt as it's walking upwards. */ gsi_insert_before (gsi, newop, GSI_NEW_STMT); gimple_assign_set_rhs1 (stmt, tem); diff --git a/gcc/tree-ssa.c b/gcc/tree-ssa.c index e4d931f862a..a945e0ea76f 100644 --- a/gcc/tree-ssa.c +++ b/gcc/tree-ssa.c @@ -1306,10 +1306,10 @@ useless_type_conversion_p (tree outer_type, tree inner_type) || TYPE_PRECISION (inner_type) != TYPE_PRECISION (outer_type)) return false; - /* Preserve conversions to BOOLEAN_TYPE if it is not of precision - one. */ - if (TREE_CODE (inner_type) != BOOLEAN_TYPE - && TREE_CODE (outer_type) == BOOLEAN_TYPE + /* Preserve conversions to/from BOOLEAN_TYPE if types are not + of precision one. */ + if (((TREE_CODE (inner_type) == BOOLEAN_TYPE) + != (TREE_CODE (outer_type) == BOOLEAN_TYPE)) && TYPE_PRECISION (outer_type) != 1) return false; -- 2.30.2