From: Richard Biener Date: Thu, 13 Nov 2014 08:53:23 +0000 (+0000) Subject: match.pd: Implement conditional expression patterns. X-Git-Url: https://git.libre-soc.org/?a=commitdiff_plain;h=96994de0451510e3c9904668e79b554bd9163e89;p=gcc.git match.pd: Implement conditional expression patterns. 2014-11-13 Richard Biener * match.pd: Implement conditional expression patterns. * tree-ssa-forwprop.c (forward_propagate_into_cond): Remove them here. (combine_cond_exprs): Remove. (pass_forwprop::execute): Do not call combine_cond_exprs. * fold-const.c (fold_ternary_loc): Remove patterns here. (pedantic_omit_one_operand_loc): Remove. From-SVN: r217465 --- diff --git a/gcc/ChangeLog b/gcc/ChangeLog index d32aa4f32bd..87dbc6e14a4 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,13 @@ +2014-11-13 Richard Biener + + * match.pd: Implement conditional expression patterns. + * tree-ssa-forwprop.c (forward_propagate_into_cond): Remove + them here. + (combine_cond_exprs): Remove. + (pass_forwprop::execute): Do not call combine_cond_exprs. + * fold-const.c (fold_ternary_loc): Remove patterns here. + (pedantic_omit_one_operand_loc): Remove. + 2014-12-13 Richard Biener PR middle-end/61559 diff --git a/gcc/fold-const.c b/gcc/fold-const.c index 4321b1ea1d2..2f32d3c9974 100644 --- a/gcc/fold-const.c +++ b/gcc/fold-const.c @@ -121,7 +121,6 @@ static enum tree_code compcode_to_comparison (enum comparison_code); static int operand_equal_for_comparison_p (tree, tree, tree); static int twoval_comparison_p (tree, tree *, tree *, int *); static tree eval_subst (location_t, tree, tree, tree, tree, tree); -static tree pedantic_omit_one_operand_loc (location_t, tree, tree, tree); static tree distribute_bit_expr (location_t, enum tree_code, tree, tree, tree); static tree make_bit_field_ref (location_t, tree, tree, HOST_WIDE_INT, HOST_WIDE_INT, int); @@ -3074,27 +3073,6 @@ omit_one_operand_loc (location_t loc, tree type, tree result, tree omitted) return non_lvalue_loc (loc, t); } -/* Similar, but call pedantic_non_lvalue instead of non_lvalue. */ - -static tree -pedantic_omit_one_operand_loc (location_t loc, tree type, tree result, - tree omitted) -{ - tree t = fold_convert_loc (loc, type, result); - - /* If the resulting operand is an empty statement, just return the omitted - statement casted to void. */ - if (IS_EMPTY_STMT (t) && TREE_SIDE_EFFECTS (omitted)) - return build1_loc (loc, NOP_EXPR, void_type_node, - fold_ignored_result (omitted)); - - if (TREE_SIDE_EFFECTS (omitted)) - return build2_loc (loc, COMPOUND_EXPR, type, - fold_ignored_result (omitted), t); - - return pedantic_non_lvalue_loc (loc, t); -} - /* Return a tree for the case when the result of an expression is RESULT converted to TYPE and OMITTED1 and OMITTED2 were previously operands of the expression but are now not needed. @@ -13553,11 +13531,6 @@ fold_ternary_loc (location_t loc, enum tree_code code, tree type, } else if (TREE_CODE (arg0) == VECTOR_CST) { - if (integer_all_onesp (arg0)) - return pedantic_omit_one_operand_loc (loc, type, arg1, arg2); - if (integer_zerop (arg0)) - return pedantic_omit_one_operand_loc (loc, type, arg2, arg1); - if ((TREE_CODE (arg1) == VECTOR_CST || TREE_CODE (arg1) == CONSTRUCTOR) && (TREE_CODE (arg2) == VECTOR_CST @@ -13582,9 +13555,6 @@ fold_ternary_loc (location_t loc, enum tree_code code, tree type, } } - if (operand_equal_p (arg1, op2, 0)) - return pedantic_omit_one_operand_loc (loc, type, arg1, arg0); - /* If we have A op B ? A : C, we may be able to convert this to a simpler expression, depending on the operation and the values of B and C. Signed zeros prevent all of these transformations, diff --git a/gcc/match.pd b/gcc/match.pd index 1d7b153af81..25711b68c68 100644 --- a/gcc/match.pd +++ b/gcc/match.pd @@ -590,3 +590,51 @@ along with GCC; see the file COPYING3. If not see (simplify (bswap (bitop:c (bswap @0) @1)) (bitop @0 (bswap @1))))) + + +/* Combine COND_EXPRs and VEC_COND_EXPRs. */ + +/* Simplify constant conditions. + Only optimize constant conditions when the selected branch + has the same type as the COND_EXPR. This avoids optimizing + away "c ? x : throw", where the throw has a void type. + Note that we cannot throw away the fold-const.c variant nor + this one as we depend on doing this transform before possibly + A ? B : B -> B triggers and the fold-const.c one can optimize + 0 ? A : B to B even if A has side-effects. Something + genmatch cannot handle. */ +(simplify + (cond INTEGER_CST@0 @1 @2) + (if (integer_zerop (@0) + && (!VOID_TYPE_P (TREE_TYPE (@2)) + || VOID_TYPE_P (type))) + @2) + (if (!integer_zerop (@0) + && (!VOID_TYPE_P (TREE_TYPE (@1)) + || VOID_TYPE_P (type))) + @1)) +(simplify + (vec_cond VECTOR_CST@0 @1 @2) + (if (integer_all_onesp (@0)) + @1) + (if (integer_zerop (@0)) + @2)) + +(for cnd (cond vec_cond) + /* A ? B : (A ? X : C) -> A ? B : C. */ + (simplify + (cnd @0 (cnd @0 @1 @2) @3) + (cnd @0 @1 @3)) + (simplify + (cnd @0 @1 (cnd @0 @2 @3)) + (cnd @0 @1 @3)) + + /* A ? B : B -> B. */ + (simplify + (cnd @0 @1 @1) + @1)) + +/* !A ? B : C -> A ? C : B. */ +(simplify + (cond (logical_inverted_value truth_valued_p@0) @1 @2) + (cond @0 @2 @1)) diff --git a/gcc/tree-ssa-forwprop.c b/gcc/tree-ssa-forwprop.c index b47f7e20251..feb82539456 100644 --- a/gcc/tree-ssa-forwprop.c +++ b/gcc/tree-ssa-forwprop.c @@ -617,7 +617,6 @@ forward_propagate_into_cond (gimple_stmt_iterator *gsi_p) tree tmp = NULL_TREE; tree cond = gimple_assign_rhs1 (stmt); enum tree_code code = gimple_assign_rhs_code (stmt); - bool swap = false; /* We can do tree combining on SSA_NAME and comparison expressions. */ if (COMPARISON_CLASS_P (cond)) @@ -640,15 +639,6 @@ forward_propagate_into_cond (gimple_stmt_iterator *gsi_p) TREE_TYPE (cond), gimple_assign_rhs1 (def_stmt), gimple_assign_rhs2 (def_stmt)); - else if (code == COND_EXPR - && ((def_code == BIT_NOT_EXPR - && TYPE_PRECISION (TREE_TYPE (cond)) == 1) - || (def_code == BIT_XOR_EXPR - && integer_onep (gimple_assign_rhs2 (def_stmt))))) - { - tmp = gimple_assign_rhs1 (def_stmt); - swap = true; - } } if (tmp @@ -669,15 +659,7 @@ forward_propagate_into_cond (gimple_stmt_iterator *gsi_p) else if (integer_zerop (tmp)) gimple_assign_set_rhs_from_tree (gsi_p, gimple_assign_rhs3 (stmt)); else - { - gimple_assign_set_rhs1 (stmt, unshare_expr (tmp)); - if (swap) - { - tree t = gimple_assign_rhs2 (stmt); - gimple_assign_set_rhs2 (stmt, gimple_assign_rhs3 (stmt)); - gimple_assign_set_rhs3 (stmt, t); - } - } + gimple_assign_set_rhs1 (stmt, unshare_expr (tmp)); stmt = gsi_stmt (*gsi_p); update_stmt (stmt); @@ -687,58 +669,6 @@ forward_propagate_into_cond (gimple_stmt_iterator *gsi_p) return 0; } -/* Propagate from the ssa name definition statements of COND_EXPR - values in the rhs of statement STMT into the conditional arms - if that simplifies it. - Returns true if the stmt was changed. */ - -static bool -combine_cond_exprs (gimple_stmt_iterator *gsi_p) -{ - gimple stmt = gsi_stmt (*gsi_p); - tree cond, val1, val2; - bool changed = false; - - cond = gimple_assign_rhs1 (stmt); - val1 = gimple_assign_rhs2 (stmt); - if (TREE_CODE (val1) == SSA_NAME) - { - gimple def_stmt = SSA_NAME_DEF_STMT (val1); - if (is_gimple_assign (def_stmt) - && gimple_assign_rhs_code (def_stmt) == gimple_assign_rhs_code (stmt) - && operand_equal_p (gimple_assign_rhs1 (def_stmt), cond, 0)) - { - val1 = unshare_expr (gimple_assign_rhs2 (def_stmt)); - gimple_assign_set_rhs2 (stmt, val1); - changed = true; - } - } - val2 = gimple_assign_rhs3 (stmt); - if (TREE_CODE (val2) == SSA_NAME) - { - gimple def_stmt = SSA_NAME_DEF_STMT (val2); - if (is_gimple_assign (def_stmt) - && gimple_assign_rhs_code (def_stmt) == gimple_assign_rhs_code (stmt) - && operand_equal_p (gimple_assign_rhs1 (def_stmt), cond, 0)) - { - val2 = unshare_expr (gimple_assign_rhs3 (def_stmt)); - gimple_assign_set_rhs3 (stmt, val2); - changed = true; - } - } - if (operand_equal_p (val1, val2, 0)) - { - gimple_assign_set_rhs_from_tree (gsi_p, val1); - stmt = gsi_stmt (*gsi_p); - changed = true; - } - - if (changed) - update_stmt (stmt); - - return changed; -} - /* We've just substituted an ADDR_EXPR into stmt. Update all the relevant data structures to match. */ @@ -2432,8 +2362,7 @@ pass_forwprop::execute (function *fun) || code == VEC_COND_EXPR) { /* In this case the entire COND_EXPR is in rhs1. */ - if (forward_propagate_into_cond (&gsi) - || combine_cond_exprs (&gsi)) + if (forward_propagate_into_cond (&gsi)) { changed = true; stmt = gsi_stmt (gsi);