Hi,
with not much hope that this patch gets into 4.7 version, resent revised
version for the first part of patch. I updated the patch according to comments
I got by matz on IRC yesterday.
Patch uses now vector for collecting truth &/|'s conditional chain.
Additionally it checks now consistent for VA.values before trying to access
DEF_STMT.
Bootstrapped and regression tested for all languages. Ok for apply?
Regards,
Kai
Index: gcc-trunk/gcc/cfgexpand.c
===================================================================
--- gcc-trunk.orig/gcc/cfgexpand.c
+++ gcc-trunk/gcc/cfgexpand.c
@@ -1650,6 +1650,695 @@ maybe_cleanup_end_of_block (edge e, rtx
}
}
+/* Check if statement can be considered as a "simple" one. Simples are:
+ - minimal invariant
+ - any non-SSA_NAME veriant
+ - any SSA_NAME variant without a definition statement
+ - any SSA_NAME with default definition.
+ - an assignment of kind ~X, if X is minimal invariant, or has no
+ definition statement, We exclude here floating point types for X
+ and Y, as ~ (X cmp Y) can have special meaning on floats..
+ - an assignment of kind X ^ ~0, if X is minimal invariant, or has no
+ definition statement, */
+
+static bool
+is_bool_op_p (tree op, bool *is_not)
+{
+ gimple s;
+ enum tree_code code;
+
+ *is_not = false;
+
+ /* Reject result types not of boolean kine. */
+ if (TREE_CODE (TREE_TYPE (op)) != BOOLEAN_TYPE)
+ return false;
+
+ if (is_gimple_min_invariant (op)
+ || TREE_CODE (op) != SSA_NAME)
+ return true;
+
+ if ((!SA.values || !bitmap_bit_p (SA.values, SSA_NAME_VERSION (op)))
+ && SSA_NAME_DEF_STMT (op)
+ && !SSA_NAME_IS_DEFAULT_DEF (op))
+ return false;
+ if (SSA_NAME_IS_DEFAULT_DEF (op)
+ || (s = SSA_NAME_DEF_STMT (op)) == NULL)
+ return true;
+ /* Reject statement which isn't of kind assign. */
+ if (!is_gimple_assign (s))
+ return false;
+
+ code = gimple_assign_rhs_code (s);
+
+ /* See if we have a "simple" logical not. */
+ if (code == BIT_NOT_EXPR)
+ *is_not = true;
+ else if (code == BIT_XOR_EXPR
+ && integer_all_onesp (gimple_assign_rhs2 (s)))
+ *is_not = true;
+ else
+ return false;
+
+ op = gimple_assign_rhs1 (s);
+
+ if (TREE_CODE (op) != SSA_NAME)
+ return false;
+
+ /* Can the inner statement be considered as
+ simple. */
+ if (is_gimple_min_invariant (op)
+ || SSA_NAME_IS_DEFAULT_DEF (op)
+ || SSA_NAME_DEF_STMT (op) == NULL)
+ return true;
+
+ *is_not = false;
+ return false;
+}
+
+/* This helper routine normalizes comparisons on boolean-typed operands
+ for OP1 ==/!= CST.
+ Folded patterns are:
+ X ==/!= 1 -> X !=/== 0
+ ~(X cmp Y) !=/== 0 -> (X cmp Y) ==/!= 0, if X and Y aren't floats.
+ ~(X & Y) !=/== 0 -> (X & Y) ==/!= 0
+ ~(Y | Y) !=/== 0 -> (X | Y) ==/!= 0
+ (X cmp Y) != 0 -> (X cmp Y)
+ (X cmp Y) == 0 -> (X cmp-invert Y), if X and Y aren't floats.
+ Note: We reject here operations on floats as pattern ~(float-compare)
+ can have side-effects. */
+
+static void
+normalize_truth_condition (enum tree_code *cmp, tree *op1, tree *op2)
+{
+ gimple stmt, s;
+ tree nop0, nop1, op;
+ tree type = TREE_TYPE (*op1);
+ enum tree_code code2;
+
+ if (TREE_CODE (type) != BOOLEAN_TYPE
+ || (*cmp != EQ_EXPR && *cmp != NE_EXPR)
+ || TREE_CODE (*op2) != INTEGER_CST)
+ return;
+
+ if (!SA.values
+ || TREE_CODE (*op1) != SSA_NAME
+ || (!bitmap_bit_p (SA.values, SSA_NAME_VERSION (*op1))
+ && SSA_NAME_DEF_STMT (*op1)))
+ return;
+
+ if (integer_onep (*op2))
+ {
+ *op2 = build_int_cst (type, 0);
+ *cmp = (*cmp == EQ_EXPR ? NE_EXPR : EQ_EXPR);
+ }
+
+ for (;;)
+ {
+ if (!SA.values
+ || TREE_CODE (*op1) != SSA_NAME
+ || !bitmap_bit_p (SA.values, SSA_NAME_VERSION (*op1)))
+ return;
+
+ stmt = SSA_NAME_DEF_STMT (*op1);
+ if (gimple_code (stmt) != GIMPLE_ASSIGN)
+ return;
+
+ code2 = gimple_assign_rhs_code (stmt);
+ if (code2 != BIT_NOT_EXPR)
+ break;
+ op = gimple_assign_rhs1 (stmt);
+
+ if (!SA.values
+ || TREE_CODE (op) != SSA_NAME
+ || !bitmap_bit_p (SA.values, SSA_NAME_VERSION (op)))
+ return;
+
+ s = SSA_NAME_DEF_STMT (op);
+ if (!s || gimple_code (s) != GIMPLE_ASSIGN)
+ return;
+
+ code2 = gimple_assign_rhs_code (s);
+
+ if (TREE_CODE_CLASS (code2) == tcc_comparison)
+ {
+ tree t = TREE_TYPE (gimple_assign_rhs1 (s));
+
+ /* Don't fold ~ (X cmp Y) ==/!= 0 to (X cmp Y) ==/!= 0,
+ if operands of comparison are floating-points. */
+ if (FLOAT_TYPE_P (t))
+ return;
+ }
+ else if (code2 != BIT_AND_EXPR && code2 != BIT_IOR_EXPR)
+ return;
+ *op1 = op;
+ *cmp = (*cmp == EQ_EXPR ? NE_EXPR : EQ_EXPR);
+ }
+
+ if (TREE_CODE_CLASS (code2) != tcc_comparison)
+ return;
+
+ nop0 = gimple_assign_rhs1 (stmt);
+ nop1 = gimple_assign_rhs2 (stmt);
+
+ /* Case (X cmp Y) != 0 -> X cmp Y. */
+ if (*cmp == NE_EXPR)
+ {
+ *cmp = code2;
+ *op1 = nop0;
+ *op2 = nop1;
+ return;
+ }
+
+ /* Case (X cmp Y) == 0 */
+
+ type = TREE_TYPE (nop0);
+ if (FLOAT_TYPE_P (type))
+ return;
+ code2 = invert_tree_comparison (*cmp,
+ HONOR_NANS (TYPE_MODE (type)));
+ if (code2 == ERROR_MARK)
+ return;
+ *cmp = code2;
+ *op1 = nop0;
+ *op2 = nop1;
+}
+
+/* Structure to keep some attributes of operands
+ for bitwise-and/or chain within a condition. */
+
+typedef struct {
+ tree leaf;
+ enum tree_code code;
+ tree op2;
+ tree type;
+ bool sa_valued;
+ bool is_bool;
+ bool is_trap;
+ bool has_sideeffect;
+ bool is_bool_not;
+ bool is_or;
+ bool is_and;
+ bool joined;
+} cond_assoc_t;
+
+DEF_VEC_O(cond_assoc_t);
+DEF_VEC_ALLOC_O(cond_assoc_t, heap);
+
+/* Build up operand list in OP for bitwise operand chain of kind CODE and
+ store each element in CONDS, if non-NULL..
+ CMP can be either EQ_EXPR or NE_EXPR, and op2 is integral zero.
+ Function returns the count of found elements in OP. */
+static int
+collect_cond_chain (tree op, enum tree_code code,
+ VEC (cond_assoc_t, heap) **pconds,
+ enum tree_code cmp, tree op2)
+{
+ gimple s = NULL;
+ int ret = 0;
+ bool sa_valued;
+
+ sa_valued = (SA.values
+ && TREE_CODE (op) == SSA_NAME
+ && (bitmap_bit_p (SA.values,
+ SSA_NAME_VERSION (op))
+ || SSA_NAME_DEF_STMT (op) == NULL));
+ if (TREE_CODE (op) != SSA_NAME
+ || !sa_valued
+ || (s = SSA_NAME_DEF_STMT (op)) == NULL
+ || !is_gimple_assign (s)
+ || gimple_assign_rhs_code (s) != code)
+ {
+ enum tree_code ncode = cmp;
+ tree nop2 = op2;
+ cond_assoc_t tmp;
+
+ memset (&tmp, 0, sizeof (cond_assoc_t));
+ normalize_truth_condition (&ncode, &op, &nop2);
+
+ tmp.leaf = op;
+ tmp.code = ncode;
+ tmp.op2 = nop2;
+ tmp.type = boolean_type_node;
+ tmp.sa_valued = sa_valued;
+
+ s = NULL;
+ if (TREE_CODE (op) != SSA_NAME
+ || !sa_valued
+ || (s = SSA_NAME_DEF_STMT (op)) == NULL
+ || !is_gimple_assign (s))
+ s = NULL;
+
+ if (s)
+ tmp.is_trap = gimple_could_trap_p (s);
+ if (s)
+ tmp.has_sideeffect = gimple_has_side_effects (s);
+
+ if ((ncode == EQ_EXPR || ncode == NE_EXPR)
+ && TREE_CODE (TREE_TYPE (op)) == BOOLEAN_TYPE
+ && integer_zerop (nop2))
+ {
+ tmp.is_bool_not = false;
+ tmp.is_bool = is_bool_op_p (op, &tmp.is_bool_not);
+
+ if (!tmp.is_bool || tmp.is_trap || tmp.has_sideeffect)
+ {
+ tmp.is_bool = false;
+ tmp.is_bool_not = false;
+ }
+ code = ERROR_MARK;
+ if (s && is_gimple_assign (s)
+ && TREE_CODE (TREE_TYPE (op)) == BOOLEAN_TYPE)
+ code = gimple_assign_rhs_code (s);
+ tmp.is_or = (code == BIT_IOR_EXPR);
+ tmp.is_and = (code == BIT_AND_EXPR);
+ }
+
+ VEC_safe_push (cond_assoc_t, heap, *pconds, &tmp);
+ return 1;
+ }
+ ret = collect_cond_chain (gimple_assign_rhs1 (s), code,
+ pconds, cmp, op2);
+ ret += collect_cond_chain (gimple_assign_rhs2 (s), code,
+ pconds, cmp, op2);
+
+ return ret;
+}
+
+/* This routine collects the bitwise operand chain of CODE in OP.
+ The found amount of elements is stored in *PCNT.
+ The function returns the pointer allocated buffer containing
+ *PCNT elements. */
+
+static VEC (cond_assoc_t, heap) *
+get_condition_list_for (tree op, enum tree_code code, int *pcnt,
+ enum tree_code cmp, tree cst)
+{
+ int cnt;
+ VEC (cond_assoc_t, heap) *conds = NULL;
+ cnt = collect_cond_chain (op, code, &conds, cmp, cst);
+
+ *pcnt = cnt;
+
+ return conds;
+}
+
+/* Helper function to build a binary tree.
+ If OP0 is boolean-typed, CODE is equal to NE_EXPR,
+ and OP2 is zero constant, then return OP0. Otherwise
+ the result of build2 is returned. */
+
+static tree
+build_cond_expr (enum tree_code code, tree type, tree op0, tree op1)
+{
+ if (code == NE_EXPR && integer_zerop (op1)
+ && TREE_CODE (TREE_TYPE (op0)) == BOOLEAN_TYPE)
+ return op0;
+ return build2 (code, type, op0, op1);
+}
+
+/* Deside if we can spare branch costs on combining
+ L and R operands for bitwise-and/or dependent on BRANCH_COST.
+ Function returns TRUE, if combining of L and R might be profitable,
+ otherwise FALSE is returned. */
+
+static bool
+is_bitwise_binary_simple_combine (cond_assoc_t *l, cond_assoc_t *r)
+{
+ bool op0_has_not = false, op1_has_not = false;
+ int bcosts = BRANCH_COST (optimize_insn_for_speed_p (), false);
+ int costs = 1;
+
+ /* If jumps aren't cheap avoid to turn some more codes into
+ jumpy sequences. */
+ if (bcosts > 4)
+ return true;
+
+ /* We would spare one branch, but higher the count of executed
+ instructions. */
+ if (bcosts <= 0)
+ return false;
+
+ if (l->is_bool == false || r->is_bool == false)
+ return false;
+
+ op0_has_not = l->is_bool_not;
+ op1_has_not = r->is_bool_not;
+
+ /* If L and R have inner bit-not, then there
+ are no additional costs for them. */
+ if (op0_has_not && op1_has_not)
+ op0_has_not = op1_has_not = false;
+
+ /* If comparison codes of L and R aren't equal, then
+ it might be more costy to combine them, if not
+ on arm doesn't have an inner logical-not. */
+ if (l->code != r->code)
+ {
+ if (op0_has_not)
+ op0_has_not = false;
+ else if (op1_has_not)
+ op1_has_not = false;
+ else
+ op0_has_not = true;
+ }
+ /* If leaf of L or R isn't boolean-typed, then we have at least
+ two operations to obtain result.
+ Each logical-not costs one more operation. */
+
+ if (TREE_CODE (TREE_TYPE (l->leaf)) != BOOLEAN_TYPE)
+ costs += 2;
+ else if (op0_has_not)
+ costs++;
+
+ if (TREE_CODE (TREE_TYPE (r->leaf)) != BOOLEAN_TYPE)
+ costs += 2;
+ else if (op1_has_not)
+ costs++;
+
+ if (bcosts < costs)
+ return false;
+
+ return true;
+}
+
+/* Obtain some characteristics on comparison of intergral typed
+ arguments and determine if we have here a simple combinable
+ operand.
+ In PREFIX_NOT the value TRUE is stored, if operand CA contains
+ a value-invert operation.
+ In CMP_ZERO the value TRUE is stored, if operand CA is a comparison
+ to integral zero.
+ This function returns TRUE, if a possible candidate was matched,
+ otherwise it returns FALSE. */
+
+static bool
+preeval_cond_integral (const cond_assoc_t *ca, bool *prefix_not, bool
*cmp_zero)
+{
+ gimple s = NULL;
+ tree o;
+
+ if (ca->joined == true
+ || ca->is_bool
+ || ca->is_trap || ca->has_sideeffect
+ || ca->sa_valued == false
+ || ca->is_and || ca->is_or)
+ return false;
+
+ /* Reject anything different than X !=/== 0 and X !=/== ~0. */
+ if ((ca->code != EQ_EXPR && ca->code != NE_EXPR)
+ || !INTEGRAL_TYPE_P (TREE_TYPE (ca->leaf))
+ || TREE_CODE (TREE_TYPE (ca->leaf)) == BOOLEAN_TYPE
+ || (!integer_zerop (ca->op2) && !integer_all_onesp (ca->op2)))
+ return false;
+
+ if (TREE_CODE (ca->leaf) != SSA_NAME)
+ return false;
+ *prefix_not = false;
+ *cmp_zero = integer_zerop (ca->op2);
+
+ s = SSA_NAME_DEF_STMT (ca->leaf);
+ if (!s || SSA_NAME_IS_DEFAULT_DEF (ca->leaf))
+ return true;
+
+ /* See if we have a valid ~X pattern in left-hand comparison
+ operand. */
+ if (!is_gimple_assign (s)
+ || gimple_assign_rhs_code (s) != BIT_NOT_EXPR)
+ return false;
+
+ o = gimple_assign_rhs1 (s);
+
+ if (TREE_CODE (o) != SSA_NAME
+ || !SA.values
+ || (!bitmap_bit_p (SA.values, SSA_NAME_VERSION (o))
+ && SSA_NAME_DEF_STMT (o) != NULL))
+ return false;
+
+ *prefix_not = true;
+ s = SSA_NAME_DEF_STMT (o);
+ if (!s || SSA_NAME_IS_DEFAULT_DEF (o))
+ return true;
+ *prefix_not = false;
+
+ return false;
+}
+
+/* Helper routine to do branch-cost optimization for operand-list
+ in CA with count CA_COUNT. The bitwise-binary operation BITCODE needs
+ to be toggled between and/or, if INVERTED is TRUE.
+ In PCODE the final binary result-code is stored. In POP0 and POP1
+ its final operands. */
+
+static void
+combine_conds (VEC (cond_assoc_t, heap) *ca, int ca_count, bool inverted,
+ enum tree_code bitcode, enum tree_code *pcode, tree *pop0, tree
*pop1)
+{
+ VEC (cond_assoc_t, heap) *sub_ca;
+ int sub_ca_count, i, l;
+ tree collect = NULL_TREE, tem;
+ enum tree_code chain_bitwise = bitcode;
+ enum tree_code chain_logical;
+ cond_assoc_t *ca_i, *ca_l;
+
+ if (inverted)
+ chain_bitwise = (chain_bitwise == BIT_AND_EXPR ? BIT_IOR_EXPR
+ : BIT_AND_EXPR);
+ chain_logical = (chain_bitwise == BIT_AND_EXPR ? TRUTH_ANDIF_EXPR
+ : TRUTH_ORIF_EXPR);
+
+ /* First try to combine the comparisons on integral-typed arguments, which
+ aren't boolean-typed. */
+ for (i = 0; i < ca_count; i++)
+ {
+ tree o1, o2;
+ bool op1_not = false, op2_not = false;
+ bool op1_cmp_zero = false, op2_cmp_zero = false;
+ int bcosts = BRANCH_COST (optimize_insn_for_speed_p (), false);
+
+ if (bcosts < 2)
+ break;
+ ca_i = VEC_index (cond_assoc_t, ca, i);
+ if (!preeval_cond_integral (ca_i, &op1_not, &op1_cmp_zero))
+ continue;
+
+ if ((chain_bitwise == BIT_IOR_EXPR && ca_i->code != NE_EXPR)
+ || (chain_bitwise == BIT_AND_EXPR && ca_i->code != EQ_EXPR))
+ continue;
+
+ for (l = i + 1; l < ca_count; l++)
+ {
+ tree p1;
+
+ ca_l = VEC_index (cond_assoc_t, ca, l);
+ if (!preeval_cond_integral (ca_l, &op2_not, &op2_cmp_zero))
+ continue;
+ if (ca_i->code != ca_l->code)
+ continue;
+
+ if (TREE_TYPE (ca_i->leaf) != TREE_TYPE (ca_l->leaf))
+ continue;
+
+ o1 = ca_i->leaf;
+ o2 = ca_l->leaf;
+ p1 = ca_i->op2;
+
+ if (op1_cmp_zero == op2_cmp_zero)
+ {
+ if (op2_not && op1_not)
+ {
+ o1 = gimple_assign_rhs1 (SSA_NAME_DEF_STMT (o1));
+ p1 = fold_build1 (BIT_NOT_EXPR, TREE_TYPE (p1), p1);
+ o2 = gimple_assign_rhs1 (SSA_NAME_DEF_STMT (o2));
+ op1_cmp_zero = !op1_cmp_zero;
+ }
+ else if ((op1_not || op2_not) && bcosts <= 2)
+ continue;
+ }
+ else if (!op1_not && !op2_not)
+ continue;
+ else if (op1_not)
+ {
+ if (op2_not && bcosts <= 2)
+ continue;
+ o1 = gimple_assign_rhs1 (SSA_NAME_DEF_STMT (o1));
+ p1 = fold_build1 (BIT_NOT_EXPR, TREE_TYPE (p1), p1);
+ op1_cmp_zero = !op1_cmp_zero;
+ }
+ else
+ o2 = gimple_assign_rhs1 (SSA_NAME_DEF_STMT (o2));
+
+ if (op1_cmp_zero)
+ ca_i->leaf = build2 (BIT_IOR_EXPR, TREE_TYPE (o1), o1, o2);
+ else
+ ca_i->leaf = build2 (BIT_AND_EXPR, TREE_TYPE (o1), o1, o2);
+ ca_i->op2 = p1;
+ ca_l->joined = true;
+ break;
+ }
+ }
+
+ /* Now try to combine comparisons on boolean-typed arguments and do
+ operations for inner bitwise and/or chains. */
+ for (i = 0; i < ca_count; i++)
+ {
+ ca_i = VEC_index (cond_assoc_t, ca, i);
+ if (ca_i->joined == true)
+ continue;
+
+ if (ca_i->is_and || ca_i->is_or)
+ {
+ enum tree_code sub_code;
+ tree op0;
+ tree cst = ca_i->op2;
+ enum tree_code ao_code = ca_i->code;
+
+ sub_ca = get_condition_list_for (ca_i->leaf,
+ (ca_i->is_and ? BIT_AND_EXPR :
BIT_IOR_EXPR),
+ &sub_ca_count,
+ ao_code, cst);
+ combine_conds (sub_ca, sub_ca_count, (ao_code == EQ_EXPR),
+ (ca_i->is_and ? BIT_AND_EXPR : BIT_IOR_EXPR),
+ &sub_code, &op0, &cst);
+ VEC_free (cond_assoc_t, heap, sub_ca);
+ sub_ca = NULL;
+ tem = build_cond_expr (sub_code, ca_i->type, op0, cst);
+ ca_i->joined = true;
+ }
+ else
+ {
+ ca_i->joined = true;
+ tem = NULL_TREE;
+ if (ca_i->is_bool)
+ {
+ for (l = i + 1; l < ca_count; l++)
+ {
+ ca_l = VEC_index (cond_assoc_t, ca, l);
+ if (ca_l->joined == true || ca_l->is_bool == false)
+ continue;
+ if (is_bitwise_binary_simple_combine (ca_i, ca_l))
+ break;
+ }
+ if (l < ca_count)
+ {
+ tree tem2;
+ enum tree_code bitw = chain_bitwise;
+
+ ca_l = VEC_index (cond_assoc_t, ca, l);
+ /* ~X == 0 -> X != 0, ~X != 0 -> X == 0 */
+ if (ca_i->is_bool_not && ca_l->is_bool_not)
+ {
+ gimple s = SSA_NAME_DEF_STMT (ca_i->leaf);
+ ca_i->leaf = gimple_assign_rhs1 (s);
+ ca_i->code = (ca_i->code == EQ_EXPR ? NE_EXPR : EQ_EXPR);
+ s = SSA_NAME_DEF_STMT (ca_l->leaf);
+ ca_l->leaf = gimple_assign_rhs1 (s);
+ ca_l->code = (ca_l->code == EQ_EXPR ? NE_EXPR : EQ_EXPR);
+ }
+ if (ca_i->code != ca_l->code)
+ {
+ gimple s;
+
+ if (ca_i->is_bool_not)
+ {
+ s = SSA_NAME_DEF_STMT (ca_i->leaf);
+ ca_i->leaf = gimple_assign_rhs1 (s);
+ ca_i->code = (ca_i->code == EQ_EXPR ? NE_EXPR :
EQ_EXPR);
+ }
+ else
+ {
+ s = SSA_NAME_DEF_STMT (ca_l->leaf);
+ ca_l->leaf = gimple_assign_rhs1 (s);
+ ca_l->code = (ca_l->code == EQ_EXPR ? NE_EXPR :
EQ_EXPR);
+ }
+ }
+ /* (X == 0 op Y == 0) != 0 -> (X op-inv Y) == 0. */
+ if (ca_i->code == EQ_EXPR && ca_l->code == EQ_EXPR)
+ {
+ bitw = (bitw == BIT_AND_EXPR ? BIT_IOR_EXPR
+ : BIT_AND_EXPR);
+ tem = build_cond_expr (NE_EXPR, ca_i->type,
+ ca_i->leaf, ca_i->op2);
+ tem2 = build_cond_expr (NE_EXPR, ca_l->type,
+ ca_l->leaf, ca_l->op2);
+ tem = build_cond_expr (bitw,
+ TREE_TYPE (tem), tem, tem2);
+ tem = build_cond_expr (EQ_EXPR, ca_i->type, tem,
+ ca_i->op2);
+ }
+ else
+ {
+ tem = build_cond_expr (ca_i->code, ca_i->type,
+ ca_i->leaf, ca_i->op2);
+ tem2 = build_cond_expr (ca_l->code, ca_l->type,
+ ca_l->leaf, ca_l->op2);
+ tem = build_cond_expr (bitw,
+ TREE_TYPE (tem), tem, tem2);
+ }
+ ca_l->joined = true;
+ }
+ }
+
+ if (!tem)
+ tem = build_cond_expr (ca_i->code, ca_i->type, ca_i->leaf,
ca_i->op2);
+ }
+
+ if (!collect)
+ collect = tem;
+ else
+ collect = build2 (chain_logical, TREE_TYPE (collect), collect, tem);
+ }
+
+ *pcode = TREE_CODE (collect);
+ *pop0 = TREE_OPERAND (collect, 0);
+ *pop1 = TREE_OPERAND (collect, 1);
+}
+
+/* Helper routine to do branch-cost optimization on binary expression
+ *POP0 *PCODE *POP1. */
+
+static void
+branchcost_optimization_on_conditions (enum tree_code *pcode, tree *pop0,
+ tree *pop1)
+{
+ tree op0 = *pop0;
+ tree op1 = *pop1;
+ tree type = TREE_TYPE (op0);
+ enum tree_code code = *pcode;
+ gimple stmt;
+ bool invert = false;
+ VEC (cond_assoc_t, heap) *ca = NULL;
+ int ca_count;
+
+ if (TREE_CODE (type) != BOOLEAN_TYPE
+ || !integer_zerop (op1)
+ || (code != EQ_EXPR && code != NE_EXPR))
+ return;
+
+ if (!SA.values
+ || TREE_CODE (op0) != SSA_NAME
+ || !bitmap_bit_p (SA.values, SSA_NAME_VERSION (op0)))
+ return;
+
+ invert = (code == EQ_EXPR);
+ stmt = SSA_NAME_DEF_STMT (op0);
+ if (gimple_code (stmt) != GIMPLE_ASSIGN)
+ return;
+ switch (gimple_assign_rhs_code (stmt))
+ {
+ case BIT_AND_EXPR:
+ case BIT_IOR_EXPR:
+ break;
+ default:
+ return;
+ }
+
+ ca = get_condition_list_for (op0, gimple_assign_rhs_code (stmt),
+ &ca_count, code, op1);
+ combine_conds (ca, ca_count, invert, gimple_assign_rhs_code (stmt),
+ pcode, pop0, pop1);
+ VEC_free (cond_assoc_t, heap, ca);
+}
+
/* A subroutine of expand_gimple_basic_block. Expand one GIMPLE_COND.
Returns a new basic block if we've terminated the current basic
block and created a new one. */
@@ -1668,6 +2357,8 @@ expand_gimple_cond (basic_block bb, gimp
code = gimple_cond_code (stmt);
op0 = gimple_cond_lhs (stmt);
op1 = gimple_cond_rhs (stmt);
+
+ normalize_truth_condition (&code, &op0, &op1);
/* We're sometimes presented with such code:
D.123_1 = x < y;
if (D.123_1 != 0)
@@ -1676,44 +2367,16 @@ expand_gimple_cond (basic_block bb, gimp
be cleaned up by combine. But some pattern matchers like if-conversion
work better when there's only one compare, so make up for this
here as special exception if TER would have made the same change. */
- if (gimple_cond_single_var_p (stmt)
- && SA.values
- && TREE_CODE (op0) == SSA_NAME
- && bitmap_bit_p (SA.values, SSA_NAME_VERSION (op0)))
- {
- gimple second = SSA_NAME_DEF_STMT (op0);
- if (gimple_code (second) == GIMPLE_ASSIGN)
- {
- enum tree_code code2 = gimple_assign_rhs_code (second);
- if (TREE_CODE_CLASS (code2) == tcc_comparison)
- {
- code = code2;
- op0 = gimple_assign_rhs1 (second);
- op1 = gimple_assign_rhs2 (second);
- }
- /* If jumps are cheap turn some more codes into
- jumpy sequences. */
- else if (BRANCH_COST (optimize_insn_for_speed_p (), false) < 4)
- {
- if ((code2 == BIT_AND_EXPR
- && TYPE_PRECISION (TREE_TYPE (op0)) == 1
- && TREE_CODE (gimple_assign_rhs2 (second)) != INTEGER_CST)
- || code2 == TRUTH_AND_EXPR)
- {
- code = TRUTH_ANDIF_EXPR;
- op0 = gimple_assign_rhs1 (second);
- op1 = gimple_assign_rhs2 (second);
- }
- else if (code2 == BIT_IOR_EXPR || code2 == TRUTH_OR_EXPR)
- {
- code = TRUTH_ORIF_EXPR;
- op0 = gimple_assign_rhs1 (second);
- op1 = gimple_assign_rhs2 (second);
- }
- }
- }
- }
+ branchcost_optimization_on_conditions (&code, &op0, &op1);
+ /* Take care that final statement is a comparison, if we end
+ up with an AND or OR associative statement. */
+ if (code == BIT_AND_EXPR || code == BIT_IOR_EXPR)
+ {
+ op0 = build2 (code, TREE_TYPE (op0), op0, op1);
+ code = NE_EXPR;
+ op1 = build_int_cst (TREE_TYPE (op0), 0);
+ }
last2 = last = get_last_insn ();
extract_true_false_edges_from_block (bb, &true_edge, &false_edge);
Index: gcc-trunk/gcc/dojump.c
===================================================================
--- gcc-trunk.orig/gcc/dojump.c
+++ gcc-trunk/gcc/dojump.c
@@ -579,13 +579,12 @@ do_jump (tree exp, rtx if_false_label, r
goto normal;
/* Boolean comparisons can be compiled as TRUTH_AND_EXPR. */
-
case TRUTH_AND_EXPR:
/* High branch cost, expand as the bitwise AND of the conditions.
Do the same if the RHS has side effects, because we're effectively
turning a TRUTH_AND_EXPR into a TRUTH_ANDIF_EXPR. */
if (BRANCH_COST (optimize_insn_for_speed_p (),
- false) >= 4
+ false) >= 1
|| TREE_SIDE_EFFECTS (TREE_OPERAND (exp, 1)))
goto normal;
code = TRUTH_ANDIF_EXPR;
@@ -596,7 +595,7 @@ do_jump (tree exp, rtx if_false_label, r
/* High branch cost, expand as the bitwise OR of the conditions.
Do the same if the RHS has side effects, because we're effectively
turning a TRUTH_OR_EXPR into a TRUTH_ORIF_EXPR. */
- if (BRANCH_COST (optimize_insn_for_speed_p (), false) >= 4
+ if (BRANCH_COST (optimize_insn_for_speed_p (), false) >= 1
|| TREE_SIDE_EFFECTS (TREE_OPERAND (exp, 1)))
goto normal;
code = TRUTH_ORIF_EXPR;
Index: gcc-trunk/gcc/fold-const.c
===================================================================
--- gcc-trunk.orig/gcc/fold-const.c
+++ gcc-trunk/gcc/fold-const.c
@@ -3711,13 +3711,26 @@ simple_operand_p_2 (tree exp)
code = TREE_CODE (exp);
- if (TREE_CODE_CLASS (code) == tcc_comparison)
- return (simple_operand_p (TREE_OPERAND (exp, 0))
- && simple_operand_p (TREE_OPERAND (exp, 1)));
+ if (code == TRUTH_ANDIF_EXPR || code == TRUTH_ORIF_EXPR)
+ return false;
+
+ /* We need to recurse here tree for two reasons. First is that
+ simple_operand_p would reject too much binary/unary/expression-kind
+ expression. Secondly, tree_could_trap_p doesn't inspect all kind
+ of binary/expression/unary-expression and so misses some side-effects. */
+
+ if (TREE_CODE_CLASS (code) == tcc_binary
+ || TREE_CODE_CLASS (code) == tcc_comparison
+ || code == TRUTH_AND_EXPR || code == TRUTH_OR_EXPR
+ || code == TRUTH_XOR_EXPR)
+ return (simple_operand_p_2 (TREE_OPERAND (exp, 0))
+ && simple_operand_p_2 (TREE_OPERAND (exp, 1)));
- if (code == TRUTH_NOT_EXPR)
+ if (TREE_CODE_CLASS (code) == tcc_unary
+ || code == TRUTH_NOT_EXPR)
return simple_operand_p_2 (TREE_OPERAND (exp, 0));
+ /* This function is in some cases too strict. */
return simple_operand_p (exp);
}
@@ -4875,45 +4888,6 @@ fold_range_test (location_t loc, enum tr
return or_op ? invert_truthvalue_loc (loc, tem) : tem;
}
- /* On machines where the branch cost is expensive, if this is a
- short-circuited branch and the underlying object on both sides
- is the same, make a non-short-circuit operation. */
- else if (LOGICAL_OP_NON_SHORT_CIRCUIT
- && lhs != 0 && rhs != 0
- && (code == TRUTH_ANDIF_EXPR
- || code == TRUTH_ORIF_EXPR)
- && operand_equal_p (lhs, rhs, 0))
- {
- /* If simple enough, just rewrite. Otherwise, make a SAVE_EXPR
- unless we are at top level or LHS contains a PLACEHOLDER_EXPR, in
- which cases we can't do this. */
- if (simple_operand_p (lhs))
- return build2_loc (loc, code == TRUTH_ANDIF_EXPR
- ? TRUTH_AND_EXPR : TRUTH_OR_EXPR,
- type, op0, op1);
-
- else if (!lang_hooks.decls.global_bindings_p ()
- && !CONTAINS_PLACEHOLDER_P (lhs))
- {
- tree common = save_expr (lhs);
-
- if (0 != (lhs = build_range_check (loc, type, common,
- or_op ? ! in0_p : in0_p,
- low0, high0))
- && (0 != (rhs = build_range_check (loc, type, common,
- or_op ? ! in1_p : in1_p,
- low1, high1))))
- {
- if (strict_overflow_p)
- fold_overflow_warning (warnmsg,
- WARN_STRICT_OVERFLOW_COMPARISON);
- return build2_loc (loc, code == TRUTH_ANDIF_EXPR
- ? TRUTH_AND_EXPR : TRUTH_OR_EXPR,
- type, lhs, rhs);
- }
- }
- }
-
return 0;
}
@@ -5143,40 +5117,6 @@ fold_truth_andor_1 (location_t loc, enum
code = ((code == TRUTH_AND_EXPR || code == TRUTH_ANDIF_EXPR)
? TRUTH_AND_EXPR : TRUTH_OR_EXPR);
- /* If the RHS can be evaluated unconditionally and its operands are
- simple, it wins to evaluate the RHS unconditionally on machines
- with expensive branches. In this case, this isn't a comparison
- that can be merged. */
-
- if (BRANCH_COST (optimize_function_for_speed_p (cfun),
- false) >= 2
- && ! FLOAT_TYPE_P (TREE_TYPE (rl_arg))
- && simple_operand_p (rl_arg)
- && simple_operand_p (rr_arg))
- {
- /* Convert (a != 0) || (b != 0) into (a | b) != 0. */
- if (code == TRUTH_OR_EXPR
- && lcode == NE_EXPR && integer_zerop (lr_arg)
- && rcode == NE_EXPR && integer_zerop (rr_arg)
- && TREE_TYPE (ll_arg) == TREE_TYPE (rl_arg)
- && INTEGRAL_TYPE_P (TREE_TYPE (ll_arg)))
- return build2_loc (loc, NE_EXPR, truth_type,
- build2 (BIT_IOR_EXPR, TREE_TYPE (ll_arg),
- ll_arg, rl_arg),
- build_int_cst (TREE_TYPE (ll_arg), 0));
-
- /* Convert (a == 0) && (b == 0) into (a | b) == 0. */
- if (code == TRUTH_AND_EXPR
- && lcode == EQ_EXPR && integer_zerop (lr_arg)
- && rcode == EQ_EXPR && integer_zerop (rr_arg)
- && TREE_TYPE (ll_arg) == TREE_TYPE (rl_arg)
- && INTEGRAL_TYPE_P (TREE_TYPE (ll_arg)))
- return build2_loc (loc, EQ_EXPR, truth_type,
- build2 (BIT_IOR_EXPR, TREE_TYPE (ll_arg),
- ll_arg, rl_arg),
- build_int_cst (TREE_TYPE (ll_arg), 0));
- }
-
/* See if the comparisons can be merged. Then get all the parameters for
each side. */
@@ -8406,13 +8346,12 @@ fold_truth_andor (location_t loc, enum t
if ((tem = fold_truth_andor_1 (loc, code, type, arg0, arg1)) != 0)
return tem;
- if ((BRANCH_COST (optimize_function_for_speed_p (cfun),
- false) >= 2)
- && LOGICAL_OP_NON_SHORT_CIRCUIT
- && (code == TRUTH_AND_EXPR
- || code == TRUTH_ANDIF_EXPR
- || code == TRUTH_OR_EXPR
- || code == TRUTH_ORIF_EXPR))
+ /* Try to optimize TRUTH_AND/OR[IF]_EXPRs to associative TRUTH_AND/OR_EXPRs
+ chains. */
+ if (code == TRUTH_AND_EXPR
+ || code == TRUTH_ANDIF_EXPR
+ || code == TRUTH_OR_EXPR
+ || code == TRUTH_ORIF_EXPR)
{
enum tree_code ncode, icode;
@@ -8440,7 +8379,7 @@ fold_truth_andor (location_t loc, enum t
return fold_build2_loc (loc, icode, type, TREE_OPERAND (arg0, 0),
tem);
}
- /* Same as abouve but for (A AND[-IF] (B AND-IF C)) -> ((A AND B)
AND-IF C),
+ /* Same as above but for (A AND[-IF] (B AND-IF C)) -> ((A AND B) AND-IF
C),
or (A OR[-IF] (B OR-IF C) -> ((A OR B) OR-IF C). */
else if (TREE_CODE (arg1) == icode
&& simple_operand_p_2 (arg0)
Index: gcc-trunk/gcc/testsuite/gcc.dg/pr46909.c
===================================================================
--- gcc-trunk.orig/gcc/testsuite/gcc.dg/pr46909.c
+++ gcc-trunk/gcc/testsuite/gcc.dg/pr46909.c
@@ -13,7 +13,7 @@ foo (unsigned int x)
return -1;
}
-/* { dg-final { scan-tree-dump-times "x_\[0-9\]+\\(D\\) != 4" 1 "optimized" }
} */
+/* { dg-final { scan-tree-dump-times "x_\[0-9\]+\\(D\\) != 4" 0 "optimized" }
} */
/* { dg-final { scan-tree-dump-times "x_\[0-9\]+\\(D\\) != 6" 0 "optimized" }
} */
/* { dg-final { scan-tree-dump-times "x_\[0-9\]+\\(D\\) == 2" 0 "optimized" }
} */
/* { dg-final { scan-tree-dump-times "x_\[0-9\]+\\(D\\) == 6" 0 "optimized" }
} */
Index: gcc-trunk/gcc/testsuite/gcc.dg/tree-ssa/vrp33.c
===================================================================
--- gcc-trunk.orig/gcc/testsuite/gcc.dg/tree-ssa/vrp33.c
+++ gcc-trunk/gcc/testsuite/gcc.dg/tree-ssa/vrp33.c
@@ -3,7 +3,14 @@
/* This is from PR14052. */
-int f2(int x) { return x == 1 || x == 3 || x == 1; }
+int f2(int x)
+{
+ if (x == 1 || x == 3)
+ return 1;
+ if (x == 1)
+ return 1;
+ return 0;
+}
/* { dg-final { scan-tree-dump "Folding predicate.*== 1 to 0" "vrp1" } } */
/* { dg-final { cleanup-tree-dump "vrp1" } } */
Index: gcc-trunk/gcc/testsuite/gcc.target/i386/branch-cost1.c
===================================================================
--- gcc-trunk.orig/gcc/testsuite/gcc.target/i386/branch-cost1.c
+++ gcc-trunk/gcc/testsuite/gcc.target/i386/branch-cost1.c
@@ -11,6 +11,7 @@ foo (int a, int b)
return 0;
}
-/* { dg-final { scan-tree-dump-times "if " 2 "gimple" } } */
-/* { dg-final { scan-tree-dump-not " & " "gimple" } } */
+/* { dg-final { scan-tree-dump-times "if " 1 "gimple" } } */
+/* { dg-final { scan-tree-dump-times " & " 1 "gimple" } } */
+/* { dg-final { scan-assembler-times "jne|je" 2 } } */
/* { dg-final { cleanup-tree-dump "gimple" } } */
Index: gcc-trunk/gcc/testsuite/gcc.target/i386/branch-cost2.c
===================================================================
--- gcc-trunk.orig/gcc/testsuite/gcc.target/i386/branch-cost2.c
+++ gcc-trunk/gcc/testsuite/gcc.target/i386/branch-cost2.c
@@ -13,4 +13,5 @@ foo (int a, int b)
/* { dg-final { scan-tree-dump-times "if " 1 "gimple" } } */
/* { dg-final { scan-tree-dump-times " & " 1 "gimple" } } */
+/* { dg-final { scan-assembler-times "jne|je" 1 } } */
/* { dg-final { cleanup-tree-dump "gimple" } } */
Index: gcc-trunk/gcc/testsuite/gcc.target/i386/branch-cost3.c
===================================================================
--- gcc-trunk.orig/gcc/testsuite/gcc.target/i386/branch-cost3.c
+++ gcc-trunk/gcc/testsuite/gcc.target/i386/branch-cost3.c
@@ -13,4 +13,5 @@ foo (_Bool a, _Bool b)
/* { dg-final { scan-tree-dump-times "if " 1 "gimple" } } */
/* { dg-final { scan-tree-dump-times " & " 1 "gimple" } } */
+/* { dg-final { scan-assembler-times "jne|je" 1 } } */
/* { dg-final { cleanup-tree-dump "gimple" } } */
Index: gcc-trunk/gcc/testsuite/gcc.target/i386/branch-cost4.c
===================================================================
--- gcc-trunk.orig/gcc/testsuite/gcc.target/i386/branch-cost4.c
+++ gcc-trunk/gcc/testsuite/gcc.target/i386/branch-cost4.c
@@ -11,6 +11,7 @@ foo (_Bool a, _Bool b)
return 0;
}
-/* { dg-final { scan-tree-dump-times "if " 2 "gimple" } } */
-/* { dg-final { scan-tree-dump-not " & " "gimple" } } */
+/* { dg-final { scan-tree-dump-times "if " 1 "gimple" } } */
+/* { dg-final { scan-tree-dump-times " & " 1 "gimple" } } */
+/* { dg-final { scan-assembler-times "jne|je" 2 } } */
/* { dg-final { cleanup-tree-dump "gimple" } } */
