1 /* Conditional compare related functions
2 Copyright (C) 2014-2016 Free Software Foundation, Inc.
4 This file is part of GCC.
6 GCC is free software; you can redistribute it and/or modify it under
7 the terms of the GNU General Public License as published by the Free
8 Software Foundation; either version 3, or (at your option) any later
11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING3. If not see
18 <http://www.gnu.org/licenses/>. */
22 #include "coretypes.h"
33 #include "stor-layout.h"
34 #include "tree-ssa-live.h"
35 #include "tree-outof-ssa.h"
36 #include "cfgexpand.h"
40 /* The following functions expand conditional compare (CCMP) instructions.
41 Here is a short description about the over all algorithm:
42 * ccmp_candidate_p is used to identify the CCMP candidate
44 * expand_ccmp_expr is the main entry, which calls expand_ccmp_expr_1
47 * expand_ccmp_expr_1 uses a recursive algorithm to expand CCMP.
48 It calls two target hooks gen_ccmp_first and gen_ccmp_next to generate
50 - gen_ccmp_first expands the first compare in CCMP.
51 - gen_ccmp_next expands the following compares.
53 Both hooks return a comparison with the CC register that is equivalent
54 to the value of the gimple comparison. This is used by the next CCMP
55 and in the final conditional store.
57 * We use cstorecc4 pattern to convert the CCmode intermediate to
58 the integer mode result that expand_normal is expecting.
60 Since the operands of the later compares might clobber CC reg, we do not
61 emit the insns during expand. We keep the insn sequences in two seq
63 * prep_seq, which includes all the insns to prepare the operands.
64 * gen_seq, which includes all the compare and conditional compares.
66 If all checks OK in expand_ccmp_expr, it emits insns in prep_seq, then
69 /* Check whether G is a potential conditional compare candidate. */
71 ccmp_candidate_p (gimple
*g
)
73 tree rhs
= gimple_assign_rhs_to_tree (g
);
76 tree_code tcode
, tcode0
, tcode1
;
77 tcode
= TREE_CODE (rhs
);
79 if (tcode
!= BIT_AND_EXPR
&& tcode
!= BIT_IOR_EXPR
)
82 lhs
= gimple_assign_lhs (g
);
83 op0
= TREE_OPERAND (rhs
, 0);
84 op1
= TREE_OPERAND (rhs
, 1);
86 if ((TREE_CODE (op0
) != SSA_NAME
) || (TREE_CODE (op1
) != SSA_NAME
)
87 || !has_single_use (lhs
))
90 gs0
= get_gimple_for_ssa_name (op0
);
91 gs1
= get_gimple_for_ssa_name (op1
);
92 if (!gs0
|| !gs1
|| !is_gimple_assign (gs0
) || !is_gimple_assign (gs1
)
93 /* g, gs0 and gs1 must be in the same basic block, since current stage
94 is out-of-ssa. We can not guarantee the correctness when forwording
95 the gs0 and gs1 into g whithout DATAFLOW analysis. */
96 || gimple_bb (gs0
) != gimple_bb (gs1
)
97 || gimple_bb (gs0
) != gimple_bb (g
))
100 tcode0
= gimple_assign_rhs_code (gs0
);
101 tcode1
= gimple_assign_rhs_code (gs1
);
102 if (TREE_CODE_CLASS (tcode0
) == tcc_comparison
103 && TREE_CODE_CLASS (tcode1
) == tcc_comparison
)
105 if (TREE_CODE_CLASS (tcode0
) == tcc_comparison
106 && ccmp_candidate_p (gs1
))
108 else if (TREE_CODE_CLASS (tcode1
) == tcc_comparison
109 && ccmp_candidate_p (gs0
))
111 /* We skip ccmp_candidate_p (gs1) && ccmp_candidate_p (gs0) since
112 there is no way to set the CC flag. */
116 /* PREV is a comparison with the CC register which represents the
117 result of the previous CMP or CCMP. The function expands the
118 next compare based on G which is ANDed/ORed with the previous
119 compare depending on CODE.
120 PREP_SEQ returns all insns to prepare opearands for compare.
121 GEN_SEQ returns all compare insns. */
123 expand_ccmp_next (gimple
*g
, tree_code code
, rtx prev
,
124 rtx
*prep_seq
, rtx
*gen_seq
)
127 int unsignedp
= TYPE_UNSIGNED (TREE_TYPE (gimple_assign_rhs1 (g
)));
129 gcc_assert (code
== BIT_AND_EXPR
|| code
== BIT_IOR_EXPR
);
131 rcode
= get_rtx_code (gimple_assign_rhs_code (g
), unsignedp
);
133 return targetm
.gen_ccmp_next (prep_seq
, gen_seq
, prev
, rcode
,
134 gimple_assign_rhs1 (g
),
135 gimple_assign_rhs2 (g
),
136 get_rtx_code (code
, 0));
139 /* Expand conditional compare gimple G. A typical CCMP sequence is like:
142 CC1 = CCMP (NE (CC0, 0), CMP (e, f));
144 CCn = CCMP (NE (CCn-1, 0), CMP (...));
146 hook gen_ccmp_first is used to expand the first compare.
147 hook gen_ccmp_next is used to expand the following CCMP.
148 PREP_SEQ returns all insns to prepare opearand.
149 GEN_SEQ returns all compare insns. */
151 expand_ccmp_expr_1 (gimple
*g
, rtx
*prep_seq
, rtx
*gen_seq
)
153 rtx prep_seq_1
, gen_seq_1
;
154 rtx prep_seq_2
, gen_seq_2
;
155 tree exp
= gimple_assign_rhs_to_tree (g
);
156 tree_code code
= TREE_CODE (exp
);
157 gimple
*gs0
= get_gimple_for_ssa_name (TREE_OPERAND (exp
, 0));
158 gimple
*gs1
= get_gimple_for_ssa_name (TREE_OPERAND (exp
, 1));
160 tree_code code0
= gimple_assign_rhs_code (gs0
);
161 tree_code code1
= gimple_assign_rhs_code (gs1
);
163 gcc_assert (code
== BIT_AND_EXPR
|| code
== BIT_IOR_EXPR
);
164 gcc_assert (gs0
&& gs1
&& is_gimple_assign (gs0
) && is_gimple_assign (gs1
));
166 if (TREE_CODE_CLASS (code0
) == tcc_comparison
)
168 if (TREE_CODE_CLASS (code1
) == tcc_comparison
)
170 int unsignedp0
, unsignedp1
;
171 rtx_code rcode0
, rcode1
;
172 int speed_p
= optimize_insn_for_speed_p ();
173 rtx tmp2
, ret
= NULL_RTX
, ret2
= NULL_RTX
;
174 unsigned cost1
= MAX_COST
;
175 unsigned cost2
= MAX_COST
;
177 unsignedp0
= TYPE_UNSIGNED (TREE_TYPE (gimple_assign_rhs1 (gs0
)));
178 unsignedp1
= TYPE_UNSIGNED (TREE_TYPE (gimple_assign_rhs1 (gs1
)));
179 rcode0
= get_rtx_code (code0
, unsignedp0
);
180 rcode1
= get_rtx_code (code1
, unsignedp1
);
182 tmp
= targetm
.gen_ccmp_first (&prep_seq_1
, &gen_seq_1
, rcode0
,
183 gimple_assign_rhs1 (gs0
),
184 gimple_assign_rhs2 (gs0
));
186 tmp2
= targetm
.gen_ccmp_first (&prep_seq_2
, &gen_seq_2
, rcode1
,
187 gimple_assign_rhs1 (gs1
),
188 gimple_assign_rhs2 (gs1
));
195 ret
= expand_ccmp_next (gs1
, code
, tmp
, &prep_seq_1
, &gen_seq_1
);
196 cost1
= seq_cost (safe_as_a
<rtx_insn
*> (prep_seq_1
), speed_p
);
197 cost1
+= seq_cost (safe_as_a
<rtx_insn
*> (gen_seq_1
), speed_p
);
201 ret2
= expand_ccmp_next (gs0
, code
, tmp2
, &prep_seq_2
,
203 cost2
= seq_cost (safe_as_a
<rtx_insn
*> (prep_seq_2
), speed_p
);
204 cost2
+= seq_cost (safe_as_a
<rtx_insn
*> (gen_seq_2
), speed_p
);
209 *prep_seq
= prep_seq_2
;
210 *gen_seq
= gen_seq_2
;
214 *prep_seq
= prep_seq_1
;
215 *gen_seq
= gen_seq_1
;
220 tmp
= expand_ccmp_expr_1 (gs1
, prep_seq
, gen_seq
);
224 return expand_ccmp_next (gs0
, code
, tmp
, prep_seq
, gen_seq
);
229 gcc_assert (gimple_assign_rhs_code (gs0
) == BIT_AND_EXPR
230 || gimple_assign_rhs_code (gs0
) == BIT_IOR_EXPR
);
232 if (TREE_CODE_CLASS (gimple_assign_rhs_code (gs1
)) == tcc_comparison
)
234 tmp
= expand_ccmp_expr_1 (gs0
, prep_seq
, gen_seq
);
238 return expand_ccmp_next (gs1
, code
, tmp
, prep_seq
, gen_seq
);
242 gcc_assert (gimple_assign_rhs_code (gs1
) == BIT_AND_EXPR
243 || gimple_assign_rhs_code (gs1
) == BIT_IOR_EXPR
);
250 /* Main entry to expand conditional compare statement G.
251 Return NULL_RTX if G is not a legal candidate or expand fail.
252 Otherwise return the target. */
254 expand_ccmp_expr (gimple
*g
)
258 rtx prep_seq
, gen_seq
;
260 prep_seq
= gen_seq
= NULL_RTX
;
262 if (!ccmp_candidate_p (g
))
265 last
= get_last_insn ();
266 tmp
= expand_ccmp_expr_1 (g
, &prep_seq
, &gen_seq
);
271 machine_mode cc_mode
= CCmode
;
272 tree lhs
= gimple_assign_lhs (g
);
273 rtx_code cmp_code
= GET_CODE (tmp
);
275 #ifdef SELECT_CC_MODE
276 cc_mode
= SELECT_CC_MODE (cmp_code
, XEXP (tmp
, 0), const0_rtx
);
278 icode
= optab_handler (cstore_optab
, cc_mode
);
279 if (icode
!= CODE_FOR_nothing
)
281 machine_mode mode
= TYPE_MODE (TREE_TYPE (lhs
));
282 rtx target
= gen_reg_rtx (mode
);
284 emit_insn (prep_seq
);
287 tmp
= emit_cstore (target
, icode
, cmp_code
, cc_mode
, cc_mode
,
288 0, XEXP (tmp
, 0), const0_rtx
, 1, mode
);
294 delete_insns_since (last
);