1 /* If-conversion for vectorizer.
2 Copyright (C) 2004-2013 Free Software Foundation, Inc.
3 Contributed by Devang Patel <dpatel@apple.com>
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 3, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
21 /* This pass implements a tree level if-conversion of loops. Its
22 initial goal is to help the vectorizer to vectorize loops with
25 A short description of if-conversion:
27 o Decide if a loop is if-convertible or not.
28 o Walk all loop basic blocks in breadth first order (BFS order).
29 o Remove conditional statements (at the end of basic block)
30 and propagate condition into destination basic blocks'
32 o Replace modify expression with conditional modify expression
33 using current basic block's condition.
34 o Merge all basic blocks
35 o Replace phi nodes with conditional modify expr
36 o Merge all basic blocks into header
38 Sample transformation:
43 # i_23 = PHI <0(0), i_18(10)>;
46 if (j_15 > 41) goto <L1>; else goto <L17>;
53 # iftmp.2_4 = PHI <0(8), 42(2)>;
57 if (i_18 <= 15) goto <L19>; else goto <L18>;
67 # i_23 = PHI <0(0), i_18(10)>;
72 iftmp.2_4 = j_15 > 41 ? 42 : 0;
75 if (i_18 <= 15) goto <L19>; else goto <L18>;
85 #include "coretypes.h"
88 #include "stor-layout.h"
90 #include "basic-block.h"
91 #include "gimple-pretty-print.h"
94 #include "gimple-iterator.h"
95 #include "gimplify-me.h"
96 #include "gimple-ssa.h"
98 #include "tree-phinodes.h"
99 #include "ssa-iterators.h"
100 #include "stringpool.h"
101 #include "tree-ssanames.h"
102 #include "tree-into-ssa.h"
103 #include "tree-ssa.h"
105 #include "tree-chrec.h"
106 #include "tree-data-ref.h"
107 #include "tree-scalar-evolution.h"
108 #include "tree-pass.h"
111 /* List of basic blocks in if-conversion-suitable order. */
112 static basic_block
*ifc_bbs
;
114 /* Structure used to predicate basic blocks. This is attached to the
115 ->aux field of the BBs in the loop to be if-converted. */
116 typedef struct bb_predicate_s
{
118 /* The condition under which this basic block is executed. */
121 /* PREDICATE is gimplified, and the sequence of statements is
122 recorded here, in order to avoid the duplication of computations
123 that occur in previous conditions. See PR44483. */
124 gimple_seq predicate_gimplified_stmts
;
127 /* Returns true when the basic block BB has a predicate. */
130 bb_has_predicate (basic_block bb
)
132 return bb
->aux
!= NULL
;
135 /* Returns the gimplified predicate for basic block BB. */
138 bb_predicate (basic_block bb
)
140 return ((bb_predicate_p
) bb
->aux
)->predicate
;
143 /* Sets the gimplified predicate COND for basic block BB. */
146 set_bb_predicate (basic_block bb
, tree cond
)
148 gcc_assert ((TREE_CODE (cond
) == TRUTH_NOT_EXPR
149 && is_gimple_condexpr (TREE_OPERAND (cond
, 0)))
150 || is_gimple_condexpr (cond
));
151 ((bb_predicate_p
) bb
->aux
)->predicate
= cond
;
154 /* Returns the sequence of statements of the gimplification of the
155 predicate for basic block BB. */
157 static inline gimple_seq
158 bb_predicate_gimplified_stmts (basic_block bb
)
160 return ((bb_predicate_p
) bb
->aux
)->predicate_gimplified_stmts
;
163 /* Sets the sequence of statements STMTS of the gimplification of the
164 predicate for basic block BB. */
167 set_bb_predicate_gimplified_stmts (basic_block bb
, gimple_seq stmts
)
169 ((bb_predicate_p
) bb
->aux
)->predicate_gimplified_stmts
= stmts
;
172 /* Adds the sequence of statements STMTS to the sequence of statements
173 of the predicate for basic block BB. */
176 add_bb_predicate_gimplified_stmts (basic_block bb
, gimple_seq stmts
)
179 (&(((bb_predicate_p
) bb
->aux
)->predicate_gimplified_stmts
), stmts
);
182 /* Initializes to TRUE the predicate of basic block BB. */
185 init_bb_predicate (basic_block bb
)
187 bb
->aux
= XNEW (struct bb_predicate_s
);
188 set_bb_predicate_gimplified_stmts (bb
, NULL
);
189 set_bb_predicate (bb
, boolean_true_node
);
192 /* Free the predicate of basic block BB. */
195 free_bb_predicate (basic_block bb
)
199 if (!bb_has_predicate (bb
))
202 /* Release the SSA_NAMEs created for the gimplification of the
204 stmts
= bb_predicate_gimplified_stmts (bb
);
207 gimple_stmt_iterator i
;
209 for (i
= gsi_start (stmts
); !gsi_end_p (i
); gsi_next (&i
))
210 free_stmt_operands (gsi_stmt (i
));
217 /* Free the predicate of BB and reinitialize it with the true
221 reset_bb_predicate (basic_block bb
)
223 free_bb_predicate (bb
);
224 init_bb_predicate (bb
);
227 /* Returns a new SSA_NAME of type TYPE that is assigned the value of
228 the expression EXPR. Inserts the statement created for this
229 computation before GSI and leaves the iterator GSI at the same
233 ifc_temp_var (tree type
, tree expr
, gimple_stmt_iterator
*gsi
)
235 tree new_name
= make_temp_ssa_name (type
, NULL
, "_ifc_");
236 gimple stmt
= gimple_build_assign (new_name
, expr
);
237 gsi_insert_before (gsi
, stmt
, GSI_SAME_STMT
);
241 /* Return true when COND is a true predicate. */
244 is_true_predicate (tree cond
)
246 return (cond
== NULL_TREE
247 || cond
== boolean_true_node
248 || integer_onep (cond
));
251 /* Returns true when BB has a predicate that is not trivial: true or
255 is_predicated (basic_block bb
)
257 return !is_true_predicate (bb_predicate (bb
));
260 /* Parses the predicate COND and returns its comparison code and
261 operands OP0 and OP1. */
263 static enum tree_code
264 parse_predicate (tree cond
, tree
*op0
, tree
*op1
)
268 if (TREE_CODE (cond
) == SSA_NAME
269 && is_gimple_assign (s
= SSA_NAME_DEF_STMT (cond
)))
271 if (TREE_CODE_CLASS (gimple_assign_rhs_code (s
)) == tcc_comparison
)
273 *op0
= gimple_assign_rhs1 (s
);
274 *op1
= gimple_assign_rhs2 (s
);
275 return gimple_assign_rhs_code (s
);
278 else if (gimple_assign_rhs_code (s
) == TRUTH_NOT_EXPR
)
280 tree op
= gimple_assign_rhs1 (s
);
281 tree type
= TREE_TYPE (op
);
282 enum tree_code code
= parse_predicate (op
, op0
, op1
);
284 return code
== ERROR_MARK
? ERROR_MARK
285 : invert_tree_comparison (code
, HONOR_NANS (TYPE_MODE (type
)));
291 if (TREE_CODE_CLASS (TREE_CODE (cond
)) == tcc_comparison
)
293 *op0
= TREE_OPERAND (cond
, 0);
294 *op1
= TREE_OPERAND (cond
, 1);
295 return TREE_CODE (cond
);
301 /* Returns the fold of predicate C1 OR C2 at location LOC. */
304 fold_or_predicates (location_t loc
, tree c1
, tree c2
)
306 tree op1a
, op1b
, op2a
, op2b
;
307 enum tree_code code1
= parse_predicate (c1
, &op1a
, &op1b
);
308 enum tree_code code2
= parse_predicate (c2
, &op2a
, &op2b
);
310 if (code1
!= ERROR_MARK
&& code2
!= ERROR_MARK
)
312 tree t
= maybe_fold_or_comparisons (code1
, op1a
, op1b
,
318 return fold_build2_loc (loc
, TRUTH_OR_EXPR
, boolean_type_node
, c1
, c2
);
321 /* Returns true if N is either a constant or a SSA_NAME. */
324 constant_or_ssa_name (tree n
)
326 switch (TREE_CODE (n
))
339 /* Returns either a COND_EXPR or the folded expression if the folded
340 expression is a MIN_EXPR, a MAX_EXPR, an ABS_EXPR,
341 a constant or a SSA_NAME. */
344 fold_build_cond_expr (tree type
, tree cond
, tree rhs
, tree lhs
)
346 tree rhs1
, lhs1
, cond_expr
;
347 cond_expr
= fold_ternary (COND_EXPR
, type
, cond
,
350 if (cond_expr
== NULL_TREE
)
351 return build3 (COND_EXPR
, type
, cond
, rhs
, lhs
);
353 STRIP_USELESS_TYPE_CONVERSION (cond_expr
);
355 if (constant_or_ssa_name (cond_expr
))
358 if (TREE_CODE (cond_expr
) == ABS_EXPR
)
360 rhs1
= TREE_OPERAND (cond_expr
, 1);
361 STRIP_USELESS_TYPE_CONVERSION (rhs1
);
362 if (constant_or_ssa_name (rhs1
))
363 return build1 (ABS_EXPR
, type
, rhs1
);
366 if (TREE_CODE (cond_expr
) == MIN_EXPR
367 || TREE_CODE (cond_expr
) == MAX_EXPR
)
369 lhs1
= TREE_OPERAND (cond_expr
, 0);
370 STRIP_USELESS_TYPE_CONVERSION (lhs1
);
371 rhs1
= TREE_OPERAND (cond_expr
, 1);
372 STRIP_USELESS_TYPE_CONVERSION (rhs1
);
373 if (constant_or_ssa_name (rhs1
)
374 && constant_or_ssa_name (lhs1
))
375 return build2 (TREE_CODE (cond_expr
), type
, lhs1
, rhs1
);
377 return build3 (COND_EXPR
, type
, cond
, rhs
, lhs
);
380 /* Add condition NC to the predicate list of basic block BB. */
383 add_to_predicate_list (basic_block bb
, tree nc
)
387 if (is_true_predicate (nc
))
390 if (!is_predicated (bb
))
394 bc
= bb_predicate (bb
);
395 bc
= fold_or_predicates (EXPR_LOCATION (bc
), nc
, bc
);
396 if (is_true_predicate (bc
))
398 reset_bb_predicate (bb
);
403 /* Allow a TRUTH_NOT_EXPR around the main predicate. */
404 if (TREE_CODE (bc
) == TRUTH_NOT_EXPR
)
405 tp
= &TREE_OPERAND (bc
, 0);
408 if (!is_gimple_condexpr (*tp
))
411 *tp
= force_gimple_operand_1 (*tp
, &stmts
, is_gimple_condexpr
, NULL_TREE
);
412 add_bb_predicate_gimplified_stmts (bb
, stmts
);
414 set_bb_predicate (bb
, bc
);
417 /* Add the condition COND to the previous condition PREV_COND, and add
418 this to the predicate list of the destination of edge E. LOOP is
419 the loop to be if-converted. */
422 add_to_dst_predicate_list (struct loop
*loop
, edge e
,
423 tree prev_cond
, tree cond
)
425 if (!flow_bb_inside_loop_p (loop
, e
->dest
))
428 if (!is_true_predicate (prev_cond
))
429 cond
= fold_build2 (TRUTH_AND_EXPR
, boolean_type_node
,
432 add_to_predicate_list (e
->dest
, cond
);
435 /* Return true if one of the successor edges of BB exits LOOP. */
438 bb_with_exit_edge_p (struct loop
*loop
, basic_block bb
)
443 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
444 if (loop_exit_edge_p (loop
, e
))
450 /* Return true when PHI is if-convertible. PHI is part of loop LOOP
451 and it belongs to basic block BB.
453 PHI is not if-convertible if:
454 - it has more than 2 arguments.
456 When the flag_tree_loop_if_convert_stores is not set, PHI is not
458 - a virtual PHI is immediately used in another PHI node,
459 - there is a virtual PHI in a BB other than the loop->header. */
462 if_convertible_phi_p (struct loop
*loop
, basic_block bb
, gimple phi
)
464 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
466 fprintf (dump_file
, "-------------------------\n");
467 print_gimple_stmt (dump_file
, phi
, 0, TDF_SLIM
);
470 if (bb
!= loop
->header
&& gimple_phi_num_args (phi
) != 2)
472 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
473 fprintf (dump_file
, "More than two phi node args.\n");
477 if (flag_tree_loop_if_convert_stores
)
480 /* When the flag_tree_loop_if_convert_stores is not set, check
481 that there are no memory writes in the branches of the loop to be
483 if (virtual_operand_p (gimple_phi_result (phi
)))
485 imm_use_iterator imm_iter
;
488 if (bb
!= loop
->header
)
490 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
491 fprintf (dump_file
, "Virtual phi not on loop->header.\n");
495 FOR_EACH_IMM_USE_FAST (use_p
, imm_iter
, gimple_phi_result (phi
))
497 if (gimple_code (USE_STMT (use_p
)) == GIMPLE_PHI
)
499 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
500 fprintf (dump_file
, "Difficult to handle this virtual phi.\n");
509 /* Records the status of a data reference. This struct is attached to
510 each DR->aux field. */
513 /* -1 when not initialized, 0 when false, 1 when true. */
514 int written_at_least_once
;
516 /* -1 when not initialized, 0 when false, 1 when true. */
517 int rw_unconditionally
;
520 #define IFC_DR(DR) ((struct ifc_dr *) (DR)->aux)
521 #define DR_WRITTEN_AT_LEAST_ONCE(DR) (IFC_DR (DR)->written_at_least_once)
522 #define DR_RW_UNCONDITIONALLY(DR) (IFC_DR (DR)->rw_unconditionally)
524 /* Returns true when the memory references of STMT are read or written
525 unconditionally. In other words, this function returns true when
526 for every data reference A in STMT there exist other accesses to
527 a data reference with the same base with predicates that add up (OR-up) to
528 the true predicate: this ensures that the data reference A is touched
529 (read or written) on every iteration of the if-converted loop. */
532 memrefs_read_or_written_unconditionally (gimple stmt
,
533 vec
<data_reference_p
> drs
)
536 data_reference_p a
, b
;
537 tree ca
= bb_predicate (gimple_bb (stmt
));
539 for (i
= 0; drs
.iterate (i
, &a
); i
++)
540 if (DR_STMT (a
) == stmt
)
543 int x
= DR_RW_UNCONDITIONALLY (a
);
551 for (j
= 0; drs
.iterate (j
, &b
); j
++)
553 tree ref_base_a
= DR_REF (a
);
554 tree ref_base_b
= DR_REF (b
);
556 if (DR_STMT (b
) == stmt
)
559 while (TREE_CODE (ref_base_a
) == COMPONENT_REF
560 || TREE_CODE (ref_base_a
) == IMAGPART_EXPR
561 || TREE_CODE (ref_base_a
) == REALPART_EXPR
)
562 ref_base_a
= TREE_OPERAND (ref_base_a
, 0);
564 while (TREE_CODE (ref_base_b
) == COMPONENT_REF
565 || TREE_CODE (ref_base_b
) == IMAGPART_EXPR
566 || TREE_CODE (ref_base_b
) == REALPART_EXPR
)
567 ref_base_b
= TREE_OPERAND (ref_base_b
, 0);
569 if (!operand_equal_p (ref_base_a
, ref_base_b
, 0))
571 tree cb
= bb_predicate (gimple_bb (DR_STMT (b
)));
573 if (DR_RW_UNCONDITIONALLY (b
) == 1
574 || is_true_predicate (cb
)
575 || is_true_predicate (ca
576 = fold_or_predicates (EXPR_LOCATION (cb
), ca
, cb
)))
578 DR_RW_UNCONDITIONALLY (a
) = 1;
579 DR_RW_UNCONDITIONALLY (b
) = 1;
588 DR_RW_UNCONDITIONALLY (a
) = 0;
596 /* Returns true when the memory references of STMT are unconditionally
597 written. In other words, this function returns true when for every
598 data reference A written in STMT, there exist other writes to the
599 same data reference with predicates that add up (OR-up) to the true
600 predicate: this ensures that the data reference A is written on
601 every iteration of the if-converted loop. */
604 write_memrefs_written_at_least_once (gimple stmt
,
605 vec
<data_reference_p
> drs
)
608 data_reference_p a
, b
;
609 tree ca
= bb_predicate (gimple_bb (stmt
));
611 for (i
= 0; drs
.iterate (i
, &a
); i
++)
612 if (DR_STMT (a
) == stmt
616 int x
= DR_WRITTEN_AT_LEAST_ONCE (a
);
624 for (j
= 0; drs
.iterate (j
, &b
); j
++)
625 if (DR_STMT (b
) != stmt
627 && same_data_refs_base_objects (a
, b
))
629 tree cb
= bb_predicate (gimple_bb (DR_STMT (b
)));
631 if (DR_WRITTEN_AT_LEAST_ONCE (b
) == 1
632 || is_true_predicate (cb
)
633 || is_true_predicate (ca
= fold_or_predicates (EXPR_LOCATION (cb
),
636 DR_WRITTEN_AT_LEAST_ONCE (a
) = 1;
637 DR_WRITTEN_AT_LEAST_ONCE (b
) = 1;
645 DR_WRITTEN_AT_LEAST_ONCE (a
) = 0;
653 /* Return true when the memory references of STMT won't trap in the
654 if-converted code. There are two things that we have to check for:
656 - writes to memory occur to writable memory: if-conversion of
657 memory writes transforms the conditional memory writes into
658 unconditional writes, i.e. "if (cond) A[i] = foo" is transformed
659 into "A[i] = cond ? foo : A[i]", and as the write to memory may not
660 be executed at all in the original code, it may be a readonly
661 memory. To check that A is not const-qualified, we check that
662 there exists at least an unconditional write to A in the current
665 - reads or writes to memory are valid memory accesses for every
666 iteration. To check that the memory accesses are correctly formed
667 and that we are allowed to read and write in these locations, we
668 check that the memory accesses to be if-converted occur at every
669 iteration unconditionally. */
672 ifcvt_memrefs_wont_trap (gimple stmt
, vec
<data_reference_p
> refs
)
674 return write_memrefs_written_at_least_once (stmt
, refs
)
675 && memrefs_read_or_written_unconditionally (stmt
, refs
);
678 /* Wrapper around gimple_could_trap_p refined for the needs of the
679 if-conversion. Try to prove that the memory accesses of STMT could
680 not trap in the innermost loop containing STMT. */
683 ifcvt_could_trap_p (gimple stmt
, vec
<data_reference_p
> refs
)
685 if (gimple_vuse (stmt
)
686 && !gimple_could_trap_p_1 (stmt
, false, false)
687 && ifcvt_memrefs_wont_trap (stmt
, refs
))
690 return gimple_could_trap_p (stmt
);
693 /* Return true when STMT is if-convertible.
695 GIMPLE_ASSIGN statement is not if-convertible if,
698 - LHS is not var decl. */
701 if_convertible_gimple_assign_stmt_p (gimple stmt
,
702 vec
<data_reference_p
> refs
)
704 tree lhs
= gimple_assign_lhs (stmt
);
707 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
709 fprintf (dump_file
, "-------------------------\n");
710 print_gimple_stmt (dump_file
, stmt
, 0, TDF_SLIM
);
713 if (!is_gimple_reg_type (TREE_TYPE (lhs
)))
716 /* Some of these constrains might be too conservative. */
717 if (stmt_ends_bb_p (stmt
)
718 || gimple_has_volatile_ops (stmt
)
719 || (TREE_CODE (lhs
) == SSA_NAME
720 && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (lhs
))
721 || gimple_has_side_effects (stmt
))
723 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
724 fprintf (dump_file
, "stmt not suitable for ifcvt\n");
728 if (flag_tree_loop_if_convert_stores
)
730 if (ifcvt_could_trap_p (stmt
, refs
))
732 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
733 fprintf (dump_file
, "tree could trap...\n");
739 if (gimple_assign_rhs_could_trap_p (stmt
))
741 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
742 fprintf (dump_file
, "tree could trap...\n");
746 bb
= gimple_bb (stmt
);
748 if (TREE_CODE (lhs
) != SSA_NAME
749 && bb
!= bb
->loop_father
->header
750 && !bb_with_exit_edge_p (bb
->loop_father
, bb
))
752 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
754 fprintf (dump_file
, "LHS is not var\n");
755 print_gimple_stmt (dump_file
, stmt
, 0, TDF_SLIM
);
763 /* Return true when STMT is if-convertible.
765 A statement is if-convertible if:
766 - it is an if-convertible GIMPLE_ASSIGN,
767 - it is a GIMPLE_LABEL or a GIMPLE_COND. */
770 if_convertible_stmt_p (gimple stmt
, vec
<data_reference_p
> refs
)
772 switch (gimple_code (stmt
))
780 return if_convertible_gimple_assign_stmt_p (stmt
, refs
);
784 tree fndecl
= gimple_call_fndecl (stmt
);
787 int flags
= gimple_call_flags (stmt
);
788 if ((flags
& ECF_CONST
)
789 && !(flags
& ECF_LOOPING_CONST_OR_PURE
)
790 /* We can only vectorize some builtins at the moment,
791 so restrict if-conversion to those. */
792 && DECL_BUILT_IN (fndecl
))
799 /* Don't know what to do with 'em so don't do anything. */
800 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
802 fprintf (dump_file
, "don't know what to do\n");
803 print_gimple_stmt (dump_file
, stmt
, 0, TDF_SLIM
);
812 /* Return true when BB is if-convertible. This routine does not check
813 basic block's statements and phis.
815 A basic block is not if-convertible if:
816 - it is non-empty and it is after the exit block (in BFS order),
817 - it is after the exit block but before the latch,
818 - its edges are not normal.
820 EXIT_BB is the basic block containing the exit of the LOOP. BB is
824 if_convertible_bb_p (struct loop
*loop
, basic_block bb
, basic_block exit_bb
)
829 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
830 fprintf (dump_file
, "----------[%d]-------------\n", bb
->index
);
832 if (EDGE_COUNT (bb
->preds
) > 2
833 || EDGE_COUNT (bb
->succs
) > 2)
838 if (bb
!= loop
->latch
)
840 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
841 fprintf (dump_file
, "basic block after exit bb but before latch\n");
844 else if (!empty_block_p (bb
))
846 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
847 fprintf (dump_file
, "non empty basic block after exit bb\n");
850 else if (bb
== loop
->latch
852 && !dominated_by_p (CDI_DOMINATORS
, bb
, exit_bb
))
854 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
855 fprintf (dump_file
, "latch is not dominated by exit_block\n");
860 /* Be less adventurous and handle only normal edges. */
861 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
862 if (e
->flags
& (EDGE_EH
| EDGE_ABNORMAL
| EDGE_IRREDUCIBLE_LOOP
))
864 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
865 fprintf (dump_file
, "Difficult to handle edges\n");
869 /* At least one incoming edge has to be non-critical as otherwise edge
870 predicates are not equal to basic-block predicates of the edge
872 if (EDGE_COUNT (bb
->preds
) > 1
873 && bb
!= loop
->header
)
876 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
877 if (EDGE_COUNT (e
->src
->succs
) == 1)
881 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
882 fprintf (dump_file
, "only critical predecessors\n");
890 /* Return true when all predecessor blocks of BB are visited. The
891 VISITED bitmap keeps track of the visited blocks. */
894 pred_blocks_visited_p (basic_block bb
, bitmap
*visited
)
898 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
899 if (!bitmap_bit_p (*visited
, e
->src
->index
))
905 /* Get body of a LOOP in suitable order for if-conversion. It is
906 caller's responsibility to deallocate basic block list.
907 If-conversion suitable order is, breadth first sort (BFS) order
908 with an additional constraint: select a block only if all its
909 predecessors are already selected. */
912 get_loop_body_in_if_conv_order (const struct loop
*loop
)
914 basic_block
*blocks
, *blocks_in_bfs_order
;
917 unsigned int index
= 0;
918 unsigned int visited_count
= 0;
920 gcc_assert (loop
->num_nodes
);
921 gcc_assert (loop
->latch
!= EXIT_BLOCK_PTR_FOR_FN (cfun
));
923 blocks
= XCNEWVEC (basic_block
, loop
->num_nodes
);
924 visited
= BITMAP_ALLOC (NULL
);
926 blocks_in_bfs_order
= get_loop_body_in_bfs_order (loop
);
929 while (index
< loop
->num_nodes
)
931 bb
= blocks_in_bfs_order
[index
];
933 if (bb
->flags
& BB_IRREDUCIBLE_LOOP
)
935 free (blocks_in_bfs_order
);
936 BITMAP_FREE (visited
);
941 if (!bitmap_bit_p (visited
, bb
->index
))
943 if (pred_blocks_visited_p (bb
, &visited
)
944 || bb
== loop
->header
)
946 /* This block is now visited. */
947 bitmap_set_bit (visited
, bb
->index
);
948 blocks
[visited_count
++] = bb
;
954 if (index
== loop
->num_nodes
955 && visited_count
!= loop
->num_nodes
)
959 free (blocks_in_bfs_order
);
960 BITMAP_FREE (visited
);
964 /* Returns true when the analysis of the predicates for all the basic
965 blocks in LOOP succeeded.
967 predicate_bbs first allocates the predicates of the basic blocks.
968 These fields are then initialized with the tree expressions
969 representing the predicates under which a basic block is executed
970 in the LOOP. As the loop->header is executed at each iteration, it
971 has the "true" predicate. Other statements executed under a
972 condition are predicated with that condition, for example
979 S1 will be predicated with "x", and
980 S2 will be predicated with "!x". */
983 predicate_bbs (loop_p loop
)
987 for (i
= 0; i
< loop
->num_nodes
; i
++)
988 init_bb_predicate (ifc_bbs
[i
]);
990 for (i
= 0; i
< loop
->num_nodes
; i
++)
992 basic_block bb
= ifc_bbs
[i
];
994 gimple_stmt_iterator itr
;
996 /* The loop latch is always executed and has no extra conditions
997 to be processed: skip it. */
998 if (bb
== loop
->latch
)
1000 reset_bb_predicate (loop
->latch
);
1004 cond
= bb_predicate (bb
);
1006 for (itr
= gsi_start_bb (bb
); !gsi_end_p (itr
); gsi_next (&itr
))
1008 gimple stmt
= gsi_stmt (itr
);
1010 switch (gimple_code (stmt
))
1021 edge true_edge
, false_edge
;
1022 location_t loc
= gimple_location (stmt
);
1023 tree c
= fold_build2_loc (loc
, gimple_cond_code (stmt
),
1025 gimple_cond_lhs (stmt
),
1026 gimple_cond_rhs (stmt
));
1028 /* Add new condition into destination's predicate list. */
1029 extract_true_false_edges_from_block (gimple_bb (stmt
),
1030 &true_edge
, &false_edge
);
1032 /* If C is true, then TRUE_EDGE is taken. */
1033 add_to_dst_predicate_list (loop
, true_edge
,
1034 unshare_expr (cond
),
1037 /* If C is false, then FALSE_EDGE is taken. */
1038 c2
= build1_loc (loc
, TRUTH_NOT_EXPR
,
1039 boolean_type_node
, unshare_expr (c
));
1040 add_to_dst_predicate_list (loop
, false_edge
,
1041 unshare_expr (cond
), c2
);
1048 /* Not handled yet in if-conversion. */
1053 /* If current bb has only one successor, then consider it as an
1054 unconditional goto. */
1055 if (single_succ_p (bb
))
1057 basic_block bb_n
= single_succ (bb
);
1059 /* The successor bb inherits the predicate of its
1060 predecessor. If there is no predicate in the predecessor
1061 bb, then consider the successor bb as always executed. */
1062 if (cond
== NULL_TREE
)
1063 cond
= boolean_true_node
;
1065 add_to_predicate_list (bb_n
, cond
);
1069 /* The loop header is always executed. */
1070 reset_bb_predicate (loop
->header
);
1071 gcc_assert (bb_predicate_gimplified_stmts (loop
->header
) == NULL
1072 && bb_predicate_gimplified_stmts (loop
->latch
) == NULL
);
1077 /* Return true when LOOP is if-convertible. This is a helper function
1078 for if_convertible_loop_p. REFS and DDRS are initialized and freed
1079 in if_convertible_loop_p. */
1082 if_convertible_loop_p_1 (struct loop
*loop
,
1083 vec
<loop_p
> *loop_nest
,
1084 vec
<data_reference_p
> *refs
,
1089 basic_block exit_bb
= NULL
;
1091 /* Don't if-convert the loop when the data dependences cannot be
1092 computed: the loop won't be vectorized in that case. */
1093 res
= compute_data_dependences_for_loop (loop
, true, loop_nest
, refs
, ddrs
);
1097 calculate_dominance_info (CDI_DOMINATORS
);
1099 /* Allow statements that can be handled during if-conversion. */
1100 ifc_bbs
= get_loop_body_in_if_conv_order (loop
);
1103 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1104 fprintf (dump_file
, "Irreducible loop\n");
1108 for (i
= 0; i
< loop
->num_nodes
; i
++)
1110 basic_block bb
= ifc_bbs
[i
];
1112 if (!if_convertible_bb_p (loop
, bb
, exit_bb
))
1115 if (bb_with_exit_edge_p (loop
, bb
))
1119 res
= predicate_bbs (loop
);
1123 if (flag_tree_loop_if_convert_stores
)
1125 data_reference_p dr
;
1127 for (i
= 0; refs
->iterate (i
, &dr
); i
++)
1129 dr
->aux
= XNEW (struct ifc_dr
);
1130 DR_WRITTEN_AT_LEAST_ONCE (dr
) = -1;
1131 DR_RW_UNCONDITIONALLY (dr
) = -1;
1135 for (i
= 0; i
< loop
->num_nodes
; i
++)
1137 basic_block bb
= ifc_bbs
[i
];
1138 gimple_stmt_iterator itr
;
1140 for (itr
= gsi_start_phis (bb
); !gsi_end_p (itr
); gsi_next (&itr
))
1141 if (!if_convertible_phi_p (loop
, bb
, gsi_stmt (itr
)))
1144 /* Check the if-convertibility of statements in predicated BBs. */
1145 if (is_predicated (bb
))
1146 for (itr
= gsi_start_bb (bb
); !gsi_end_p (itr
); gsi_next (&itr
))
1147 if (!if_convertible_stmt_p (gsi_stmt (itr
), *refs
))
1152 fprintf (dump_file
, "Applying if-conversion\n");
1157 /* Return true when LOOP is if-convertible.
1158 LOOP is if-convertible if:
1160 - it has two or more basic blocks,
1161 - it has only one exit,
1162 - loop header is not the exit edge,
1163 - if its basic blocks and phi nodes are if convertible. */
1166 if_convertible_loop_p (struct loop
*loop
)
1171 vec
<data_reference_p
> refs
;
1174 /* Handle only innermost loop. */
1175 if (!loop
|| loop
->inner
)
1177 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1178 fprintf (dump_file
, "not innermost loop\n");
1182 /* If only one block, no need for if-conversion. */
1183 if (loop
->num_nodes
<= 2)
1185 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1186 fprintf (dump_file
, "less than 2 basic blocks\n");
1190 /* More than one loop exit is too much to handle. */
1191 if (!single_exit (loop
))
1193 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1194 fprintf (dump_file
, "multiple exits\n");
1198 /* If one of the loop header's edge is an exit edge then do not
1199 apply if-conversion. */
1200 FOR_EACH_EDGE (e
, ei
, loop
->header
->succs
)
1201 if (loop_exit_edge_p (loop
, e
))
1206 stack_vec
<loop_p
, 3> loop_nest
;
1207 res
= if_convertible_loop_p_1 (loop
, &loop_nest
, &refs
, &ddrs
);
1209 if (flag_tree_loop_if_convert_stores
)
1211 data_reference_p dr
;
1214 for (i
= 0; refs
.iterate (i
, &dr
); i
++)
1218 free_data_refs (refs
);
1219 free_dependence_relations (ddrs
);
1223 /* Basic block BB has two predecessors. Using predecessor's bb
1224 predicate, set an appropriate condition COND for the PHI node
1225 replacement. Return the true block whose phi arguments are
1226 selected when cond is true. LOOP is the loop containing the
1227 if-converted region, GSI is the place to insert the code for the
1231 find_phi_replacement_condition (basic_block bb
, tree
*cond
,
1232 gimple_stmt_iterator
*gsi
)
1234 edge first_edge
, second_edge
;
1237 gcc_assert (EDGE_COUNT (bb
->preds
) == 2);
1238 first_edge
= EDGE_PRED (bb
, 0);
1239 second_edge
= EDGE_PRED (bb
, 1);
1241 /* Prefer an edge with a not negated predicate.
1242 ??? That's a very weak cost model. */
1243 tmp_cond
= bb_predicate (first_edge
->src
);
1244 gcc_assert (tmp_cond
);
1245 if (TREE_CODE (tmp_cond
) == TRUTH_NOT_EXPR
)
1249 tmp_edge
= first_edge
;
1250 first_edge
= second_edge
;
1251 second_edge
= tmp_edge
;
1254 /* Check if the edge we take the condition from is not critical.
1255 We know that at least one non-critical edge exists. */
1256 if (EDGE_COUNT (first_edge
->src
->succs
) > 1)
1258 *cond
= bb_predicate (second_edge
->src
);
1260 if (TREE_CODE (*cond
) == TRUTH_NOT_EXPR
)
1261 *cond
= TREE_OPERAND (*cond
, 0);
1263 /* Select non loop header bb. */
1264 first_edge
= second_edge
;
1267 *cond
= bb_predicate (first_edge
->src
);
1269 /* Gimplify the condition to a valid cond-expr conditonal operand. */
1270 *cond
= force_gimple_operand_gsi_1 (gsi
, unshare_expr (*cond
),
1271 is_gimple_condexpr
, NULL_TREE
,
1272 true, GSI_SAME_STMT
);
1274 return first_edge
->src
;
1277 /* Replace a scalar PHI node with a COND_EXPR using COND as condition.
1278 This routine does not handle PHI nodes with more than two
1282 S1: A = PHI <x1(1), x2(5)>
1284 S2: A = cond ? x1 : x2;
1286 The generated code is inserted at GSI that points to the top of
1287 basic block's statement list. When COND is true, phi arg from
1288 TRUE_BB is selected. */
1291 predicate_scalar_phi (gimple phi
, tree cond
,
1292 basic_block true_bb
,
1293 gimple_stmt_iterator
*gsi
)
1297 tree rhs
, res
, arg
, scev
;
1299 gcc_assert (gimple_code (phi
) == GIMPLE_PHI
1300 && gimple_phi_num_args (phi
) == 2);
1302 res
= gimple_phi_result (phi
);
1303 /* Do not handle virtual phi nodes. */
1304 if (virtual_operand_p (res
))
1307 bb
= gimple_bb (phi
);
1309 if ((arg
= degenerate_phi_result (phi
))
1310 || ((scev
= analyze_scalar_evolution (gimple_bb (phi
)->loop_father
,
1312 && !chrec_contains_undetermined (scev
)
1314 && (arg
= gimple_phi_arg_def (phi
, 0))))
1319 /* Use condition that is not TRUTH_NOT_EXPR in conditional modify expr. */
1320 if (EDGE_PRED (bb
, 1)->src
== true_bb
)
1322 arg_0
= gimple_phi_arg_def (phi
, 1);
1323 arg_1
= gimple_phi_arg_def (phi
, 0);
1327 arg_0
= gimple_phi_arg_def (phi
, 0);
1328 arg_1
= gimple_phi_arg_def (phi
, 1);
1331 /* Build new RHS using selected condition and arguments. */
1332 rhs
= fold_build_cond_expr (TREE_TYPE (res
), unshare_expr (cond
),
1336 new_stmt
= gimple_build_assign (res
, rhs
);
1337 gsi_insert_before (gsi
, new_stmt
, GSI_SAME_STMT
);
1338 update_stmt (new_stmt
);
1340 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1342 fprintf (dump_file
, "new phi replacement stmt\n");
1343 print_gimple_stmt (dump_file
, new_stmt
, 0, TDF_SLIM
);
1347 /* Replaces in LOOP all the scalar phi nodes other than those in the
1348 LOOP->header block with conditional modify expressions. */
1351 predicate_all_scalar_phis (struct loop
*loop
)
1354 unsigned int orig_loop_num_nodes
= loop
->num_nodes
;
1357 for (i
= 1; i
< orig_loop_num_nodes
; i
++)
1360 tree cond
= NULL_TREE
;
1361 gimple_stmt_iterator gsi
, phi_gsi
;
1362 basic_block true_bb
= NULL
;
1365 if (bb
== loop
->header
)
1368 phi_gsi
= gsi_start_phis (bb
);
1369 if (gsi_end_p (phi_gsi
))
1372 /* BB has two predecessors. Using predecessor's aux field, set
1373 appropriate condition for the PHI node replacement. */
1374 gsi
= gsi_after_labels (bb
);
1375 true_bb
= find_phi_replacement_condition (bb
, &cond
, &gsi
);
1377 while (!gsi_end_p (phi_gsi
))
1379 phi
= gsi_stmt (phi_gsi
);
1380 predicate_scalar_phi (phi
, cond
, true_bb
, &gsi
);
1381 release_phi_node (phi
);
1382 gsi_next (&phi_gsi
);
1385 set_phi_nodes (bb
, NULL
);
1389 /* Insert in each basic block of LOOP the statements produced by the
1390 gimplification of the predicates. */
1393 insert_gimplified_predicates (loop_p loop
)
1397 for (i
= 0; i
< loop
->num_nodes
; i
++)
1399 basic_block bb
= ifc_bbs
[i
];
1402 if (!is_predicated (bb
))
1404 /* Do not insert statements for a basic block that is not
1405 predicated. Also make sure that the predicate of the
1406 basic block is set to true. */
1407 reset_bb_predicate (bb
);
1411 stmts
= bb_predicate_gimplified_stmts (bb
);
1414 if (flag_tree_loop_if_convert_stores
)
1416 /* Insert the predicate of the BB just after the label,
1417 as the if-conversion of memory writes will use this
1419 gimple_stmt_iterator gsi
= gsi_after_labels (bb
);
1420 gsi_insert_seq_before (&gsi
, stmts
, GSI_SAME_STMT
);
1424 /* Insert the predicate of the BB at the end of the BB
1425 as this would reduce the register pressure: the only
1426 use of this predicate will be in successor BBs. */
1427 gimple_stmt_iterator gsi
= gsi_last_bb (bb
);
1430 || stmt_ends_bb_p (gsi_stmt (gsi
)))
1431 gsi_insert_seq_before (&gsi
, stmts
, GSI_SAME_STMT
);
1433 gsi_insert_seq_after (&gsi
, stmts
, GSI_SAME_STMT
);
1436 /* Once the sequence is code generated, set it to NULL. */
1437 set_bb_predicate_gimplified_stmts (bb
, NULL
);
1442 /* Predicate each write to memory in LOOP.
1444 This function transforms control flow constructs containing memory
1447 | for (i = 0; i < N; i++)
1451 into the following form that does not contain control flow:
1453 | for (i = 0; i < N; i++)
1454 | A[i] = cond ? expr : A[i];
1456 The original CFG looks like this:
1463 | if (i < N) goto bb_5 else goto bb_2
1467 | cond = some_computation;
1468 | if (cond) goto bb_3 else goto bb_4
1480 insert_gimplified_predicates inserts the computation of the COND
1481 expression at the beginning of the destination basic block:
1488 | if (i < N) goto bb_5 else goto bb_2
1492 | cond = some_computation;
1493 | if (cond) goto bb_3 else goto bb_4
1497 | cond = some_computation;
1506 predicate_mem_writes is then predicating the memory write as follows:
1513 | if (i < N) goto bb_5 else goto bb_2
1517 | if (cond) goto bb_3 else goto bb_4
1521 | cond = some_computation;
1522 | A[i] = cond ? expr : A[i];
1530 and finally combine_blocks removes the basic block boundaries making
1531 the loop vectorizable:
1535 | if (i < N) goto bb_5 else goto bb_1
1539 | cond = some_computation;
1540 | A[i] = cond ? expr : A[i];
1541 | if (i < N) goto bb_5 else goto bb_4
1550 predicate_mem_writes (loop_p loop
)
1552 unsigned int i
, orig_loop_num_nodes
= loop
->num_nodes
;
1554 for (i
= 1; i
< orig_loop_num_nodes
; i
++)
1556 gimple_stmt_iterator gsi
;
1557 basic_block bb
= ifc_bbs
[i
];
1558 tree cond
= bb_predicate (bb
);
1562 if (is_true_predicate (cond
))
1566 if (TREE_CODE (cond
) == TRUTH_NOT_EXPR
)
1569 cond
= TREE_OPERAND (cond
, 0);
1572 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1573 if ((stmt
= gsi_stmt (gsi
))
1574 && gimple_assign_single_p (stmt
)
1575 && gimple_vdef (stmt
))
1577 tree lhs
= gimple_assign_lhs (stmt
);
1578 tree rhs
= gimple_assign_rhs1 (stmt
);
1579 tree type
= TREE_TYPE (lhs
);
1581 lhs
= ifc_temp_var (type
, unshare_expr (lhs
), &gsi
);
1582 rhs
= ifc_temp_var (type
, unshare_expr (rhs
), &gsi
);
1589 cond
= force_gimple_operand_gsi_1 (&gsi
, unshare_expr (cond
),
1590 is_gimple_condexpr
, NULL_TREE
,
1591 true, GSI_SAME_STMT
);
1592 rhs
= fold_build_cond_expr (type
, unshare_expr (cond
), rhs
, lhs
);
1593 gimple_assign_set_rhs1 (stmt
, ifc_temp_var (type
, rhs
, &gsi
));
1599 /* Remove all GIMPLE_CONDs and GIMPLE_LABELs of all the basic blocks
1600 other than the exit and latch of the LOOP. Also resets the
1601 GIMPLE_DEBUG information. */
1604 remove_conditions_and_labels (loop_p loop
)
1606 gimple_stmt_iterator gsi
;
1609 for (i
= 0; i
< loop
->num_nodes
; i
++)
1611 basic_block bb
= ifc_bbs
[i
];
1613 if (bb_with_exit_edge_p (loop
, bb
)
1614 || bb
== loop
->latch
)
1617 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); )
1618 switch (gimple_code (gsi_stmt (gsi
)))
1622 gsi_remove (&gsi
, true);
1626 /* ??? Should there be conditional GIMPLE_DEBUG_BINDs? */
1627 if (gimple_debug_bind_p (gsi_stmt (gsi
)))
1629 gimple_debug_bind_reset_value (gsi_stmt (gsi
));
1630 update_stmt (gsi_stmt (gsi
));
1641 /* Combine all the basic blocks from LOOP into one or two super basic
1642 blocks. Replace PHI nodes with conditional modify expressions. */
1645 combine_blocks (struct loop
*loop
)
1647 basic_block bb
, exit_bb
, merge_target_bb
;
1648 unsigned int orig_loop_num_nodes
= loop
->num_nodes
;
1653 remove_conditions_and_labels (loop
);
1654 insert_gimplified_predicates (loop
);
1655 predicate_all_scalar_phis (loop
);
1657 if (flag_tree_loop_if_convert_stores
)
1658 predicate_mem_writes (loop
);
1660 /* Merge basic blocks: first remove all the edges in the loop,
1661 except for those from the exit block. */
1663 for (i
= 0; i
< orig_loop_num_nodes
; i
++)
1666 free_bb_predicate (bb
);
1667 if (bb_with_exit_edge_p (loop
, bb
))
1669 gcc_assert (exit_bb
== NULL
);
1673 gcc_assert (exit_bb
!= loop
->latch
);
1675 for (i
= 1; i
< orig_loop_num_nodes
; i
++)
1679 for (ei
= ei_start (bb
->preds
); (e
= ei_safe_edge (ei
));)
1681 if (e
->src
== exit_bb
)
1688 if (exit_bb
!= NULL
)
1690 if (exit_bb
!= loop
->header
)
1692 /* Connect this node to loop header. */
1693 make_edge (loop
->header
, exit_bb
, EDGE_FALLTHRU
);
1694 set_immediate_dominator (CDI_DOMINATORS
, exit_bb
, loop
->header
);
1697 /* Redirect non-exit edges to loop->latch. */
1698 FOR_EACH_EDGE (e
, ei
, exit_bb
->succs
)
1700 if (!loop_exit_edge_p (loop
, e
))
1701 redirect_edge_and_branch (e
, loop
->latch
);
1703 set_immediate_dominator (CDI_DOMINATORS
, loop
->latch
, exit_bb
);
1707 /* If the loop does not have an exit, reconnect header and latch. */
1708 make_edge (loop
->header
, loop
->latch
, EDGE_FALLTHRU
);
1709 set_immediate_dominator (CDI_DOMINATORS
, loop
->latch
, loop
->header
);
1712 merge_target_bb
= loop
->header
;
1713 for (i
= 1; i
< orig_loop_num_nodes
; i
++)
1715 gimple_stmt_iterator gsi
;
1716 gimple_stmt_iterator last
;
1720 if (bb
== exit_bb
|| bb
== loop
->latch
)
1723 /* Make stmts member of loop->header. */
1724 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1725 gimple_set_bb (gsi_stmt (gsi
), merge_target_bb
);
1727 /* Update stmt list. */
1728 last
= gsi_last_bb (merge_target_bb
);
1729 gsi_insert_seq_after (&last
, bb_seq (bb
), GSI_NEW_STMT
);
1730 set_bb_seq (bb
, NULL
);
1732 delete_basic_block (bb
);
1735 /* If possible, merge loop header to the block with the exit edge.
1736 This reduces the number of basic blocks to two, to please the
1737 vectorizer that handles only loops with two nodes. */
1739 && exit_bb
!= loop
->header
1740 && can_merge_blocks_p (loop
->header
, exit_bb
))
1741 merge_blocks (loop
->header
, exit_bb
);
1747 /* If-convert LOOP when it is legal. For the moment this pass has no
1748 profitability analysis. Returns true when something changed. */
1751 tree_if_conversion (struct loop
*loop
)
1753 bool changed
= false;
1756 if (!if_convertible_loop_p (loop
)
1757 || !dbg_cnt (if_conversion_tree
))
1760 /* Now all statements are if-convertible. Combine all the basic
1761 blocks into one huge basic block doing the if-conversion
1763 combine_blocks (loop
);
1765 if (flag_tree_loop_if_convert_stores
)
1766 mark_virtual_operands_for_renaming (cfun
);
1775 for (i
= 0; i
< loop
->num_nodes
; i
++)
1776 free_bb_predicate (ifc_bbs
[i
]);
1785 /* Tree if-conversion pass management. */
1788 main_tree_if_conversion (void)
1791 bool changed
= false;
1794 if (number_of_loops (cfun
) <= 1)
1797 FOR_EACH_LOOP (loop
, 0)
1798 if (flag_tree_loop_if_convert
== 1
1799 || flag_tree_loop_if_convert_stores
== 1
1800 || flag_tree_loop_vectorize
1801 || loop
->force_vect
)
1802 changed
|= tree_if_conversion (loop
);
1805 todo
|= TODO_cleanup_cfg
;
1807 if (changed
&& flag_tree_loop_if_convert_stores
)
1808 todo
|= TODO_update_ssa_only_virtuals
;
1810 #ifdef ENABLE_CHECKING
1814 gcc_assert (!bb
->aux
);
1821 /* Returns true when the if-conversion pass is enabled. */
1824 gate_tree_if_conversion (void)
1826 return (((flag_tree_loop_vectorize
|| cfun
->has_force_vect_loops
)
1827 && flag_tree_loop_if_convert
!= 0)
1828 || flag_tree_loop_if_convert
== 1
1829 || flag_tree_loop_if_convert_stores
== 1);
1834 const pass_data pass_data_if_conversion
=
1836 GIMPLE_PASS
, /* type */
1838 OPTGROUP_NONE
, /* optinfo_flags */
1839 true, /* has_gate */
1840 true, /* has_execute */
1841 TV_NONE
, /* tv_id */
1842 ( PROP_cfg
| PROP_ssa
), /* properties_required */
1843 0, /* properties_provided */
1844 0, /* properties_destroyed */
1845 0, /* todo_flags_start */
1846 ( TODO_verify_stmts
| TODO_verify_flow
1847 | TODO_verify_ssa
), /* todo_flags_finish */
1850 class pass_if_conversion
: public gimple_opt_pass
1853 pass_if_conversion (gcc::context
*ctxt
)
1854 : gimple_opt_pass (pass_data_if_conversion
, ctxt
)
1857 /* opt_pass methods: */
1858 bool gate () { return gate_tree_if_conversion (); }
1859 unsigned int execute () { return main_tree_if_conversion (); }
1861 }; // class pass_if_conversion
1866 make_pass_if_conversion (gcc::context
*ctxt
)
1868 return new pass_if_conversion (ctxt
);