/* Main entry to expand conditional compare statement G.
Return NULL_RTX if G is not a legal candidate or expand fail.
Otherwise return the target. */
rtx
expand_ccmp_expr (gimple *g)
{
rtx_insn *last;
rtx tmp;
rtx prep_seq, gen_seq;
prep_seq = gen_seq = NULL_RTX;
if (!ccmp_candidate_p (g))
return NULL_RTX;
last = get_last_insn ();
tmp = expand_ccmp_expr_1 (g, &prep_seq, &gen_seq);
if (tmp)
{
enum insn_code icode;
enum machine_mode cc_mode = CCmode;
tree lhs = gimple_assign_lhs (g);
#ifdef SELECT_CC_MODE
cc_mode = SELECT_CC_MODE (NE, tmp, const0_rtx);
#endif
icode = optab_handler (cstore_optab, cc_mode);
if (icode != CODE_FOR_nothing)
{
enum machine_mode mode = TYPE_MODE (TREE_TYPE (lhs));
rtx target = gen_reg_rtx (mode);
emit_insn (prep_seq);
emit_insn (gen_seq);
tmp = emit_cstore (target, icode, NE, cc_mode, cc_mode,
0, tmp, const0_rtx, 1, mode);
if (tmp)
return tmp;
}
}
/* Clean up. */
delete_insns_since (last);
return NULL_RTX;
}
/* Expand conditional compare gimple G. A typical CCMP sequence is like:
CC0 = CMP (a, b);
CC1 = CCMP (NE (CC0, 0), CMP (e, f));
...
CCn = CCMP (NE (CCn-1, 0), CMP (...));
hook gen_ccmp_first is used to expand the first compare.
hook gen_ccmp_next is used to expand the following CCMP.
PREP_SEQ returns all insns to prepare opearand.
GEN_SEQ returns all compare insns. */
static rtx
expand_ccmp_expr_1 (gimple *g, rtx *prep_seq, rtx *gen_seq)
{
tree exp = gimple_assign_rhs_to_tree (g);
enum tree_code code = TREE_CODE (exp);
gimple *gs0 = get_gimple_for_ssa_name (TREE_OPERAND (exp, 0));
gimple *gs1 = get_gimple_for_ssa_name (TREE_OPERAND (exp, 1));
rtx tmp;
enum tree_code code0 = gimple_assign_rhs_code (gs0);
enum tree_code code1 = gimple_assign_rhs_code (gs1);
gcc_assert (code == BIT_AND_EXPR || code == BIT_IOR_EXPR);
gcc_assert (gs0 && gs1 && is_gimple_assign (gs0) && is_gimple_assign (gs1));
if (TREE_CODE_CLASS (code0) == tcc_comparison)
{
if (TREE_CODE_CLASS (code1) == tcc_comparison)
{
int unsignedp0;
enum rtx_code rcode0;
unsignedp0 = TYPE_UNSIGNED (TREE_TYPE (gimple_assign_rhs1 (gs0)));
rcode0 = get_rtx_code (code0, unsignedp0);
tmp = targetm.gen_ccmp_first (prep_seq, gen_seq, rcode0,
gimple_assign_rhs1 (gs0),
gimple_assign_rhs2 (gs0));
if (!tmp)
return NULL_RTX;
return expand_ccmp_next (gs1, code, tmp, prep_seq, gen_seq);
}
else
{
tmp = expand_ccmp_expr_1 (gs1, prep_seq, gen_seq);
if (!tmp)
return NULL_RTX;
return expand_ccmp_next (gs0, code, tmp, prep_seq, gen_seq);
}
}
else
{
gcc_assert (gimple_assign_rhs_code (gs0) == BIT_AND_EXPR
|| gimple_assign_rhs_code (gs0) == BIT_IOR_EXPR);
if (TREE_CODE_CLASS (gimple_assign_rhs_code (gs1)) == tcc_comparison)
{
tmp = expand_ccmp_expr_1 (gs0, prep_seq, gen_seq);
if (!tmp)
return NULL_RTX;
return expand_ccmp_next (gs1, code, tmp, prep_seq, gen_seq);
}
else
{
gcc_assert (gimple_assign_rhs_code (gs1) == BIT_AND_EXPR
|| gimple_assign_rhs_code (gs1) == BIT_IOR_EXPR);
}
}
return NULL_RTX;
}
/* Expand conditional compare gimple G. A typical CCMP sequence is like:
CC0 = CMP (a, b);
CC1 = CCMP (NE (CC0, 0), CMP (e, f));
...
CCn = CCMP (NE (CCn-1, 0), CMP (...));
hook gen_ccmp_first is used to expand the first compare.
hook gen_ccmp_next is used to expand the following CCMP.
PREP_SEQ returns all insns to prepare opearand.
GEN_SEQ returns all compare insns. */
static rtx
expand_ccmp_expr_1 (gimple *g, rtx_insn **prep_seq, rtx_insn **gen_seq)
{
tree exp = gimple_assign_rhs_to_tree (g);
tree_code code = TREE_CODE (exp);
gimple *gs0 = get_gimple_for_ssa_name (TREE_OPERAND (exp, 0));
gimple *gs1 = get_gimple_for_ssa_name (TREE_OPERAND (exp, 1));
rtx tmp;
tree_code code0 = gimple_assign_rhs_code (gs0);
tree_code code1 = gimple_assign_rhs_code (gs1);
gcc_assert (code == BIT_AND_EXPR || code == BIT_IOR_EXPR);
gcc_assert (gs0 && gs1 && is_gimple_assign (gs0) && is_gimple_assign (gs1));
if (TREE_CODE_CLASS (code0) == tcc_comparison)
{
if (TREE_CODE_CLASS (code1) == tcc_comparison)
{
int unsignedp0, unsignedp1;
rtx_code rcode0, rcode1;
int speed_p = optimize_insn_for_speed_p ();
rtx tmp2 = NULL_RTX, ret = NULL_RTX, ret2 = NULL_RTX;
unsigned cost1 = MAX_COST;
unsigned cost2 = MAX_COST;
unsignedp0 = TYPE_UNSIGNED (TREE_TYPE (gimple_assign_rhs1 (gs0)));
unsignedp1 = TYPE_UNSIGNED (TREE_TYPE (gimple_assign_rhs1 (gs1)));
rcode0 = get_rtx_code (code0, unsignedp0);
rcode1 = get_rtx_code (code1, unsignedp1);
rtx_insn *prep_seq_1, *gen_seq_1;
tmp = targetm.gen_ccmp_first (&prep_seq_1, &gen_seq_1, rcode0,
gimple_assign_rhs1 (gs0),
gimple_assign_rhs2 (gs0));
if (tmp != NULL)
{
ret = expand_ccmp_next (gs1, code, tmp, &prep_seq_1, &gen_seq_1);
cost1 = seq_cost (prep_seq_1, speed_p);
cost1 += seq_cost (gen_seq_1, speed_p);
}
/* FIXME: Temporary workaround for PR69619.
Avoid exponential compile time due to expanding gs0 and gs1 twice.
If gs0 and gs1 are complex, the cost will be high, so avoid
reevaluation if above an arbitrary threshold. */
rtx_insn *prep_seq_2, *gen_seq_2;
if (tmp == NULL || cost1 < COSTS_N_INSNS (25))
tmp2 = targetm.gen_ccmp_first (&prep_seq_2, &gen_seq_2, rcode1,
gimple_assign_rhs1 (gs1),
gimple_assign_rhs2 (gs1));
if (!tmp && !tmp2)
return NULL_RTX;
if (tmp2 != NULL)
{
ret2 = expand_ccmp_next (gs0, code, tmp2, &prep_seq_2,
&gen_seq_2);
cost2 = seq_cost (prep_seq_2, speed_p);
cost2 += seq_cost (gen_seq_2, speed_p);
}
if (cost2 < cost1)
{
*prep_seq = prep_seq_2;
*gen_seq = gen_seq_2;
return ret2;
}
*prep_seq = prep_seq_1;
*gen_seq = gen_seq_1;
return ret;
}
else
{
tmp = expand_ccmp_expr_1 (gs1, prep_seq, gen_seq);
if (!tmp)
return NULL_RTX;
return expand_ccmp_next (gs0, code, tmp, prep_seq, gen_seq);
}
}
else
{
gcc_assert (gimple_assign_rhs_code (gs0) == BIT_AND_EXPR
|| gimple_assign_rhs_code (gs0) == BIT_IOR_EXPR);
if (TREE_CODE_CLASS (gimple_assign_rhs_code (gs1)) == tcc_comparison)
{
tmp = expand_ccmp_expr_1 (gs0, prep_seq, gen_seq);
if (!tmp)
return NULL_RTX;
return expand_ccmp_next (gs1, code, tmp, prep_seq, gen_seq);
}
else
{
gcc_assert (gimple_assign_rhs_code (gs1) == BIT_AND_EXPR
|| gimple_assign_rhs_code (gs1) == BIT_IOR_EXPR);
}
}
return NULL_RTX;
}