1 /* Dead code elimination pass for the GNU compiler.
2 Copyright (C) 2002-2014 Free Software Foundation, Inc.
3 Contributed by Ben Elliston <bje@redhat.com>
4 and Andrew MacLeod <amacleod@redhat.com>
5 Adapted to use control dependence by Steven Bosscher, SUSE Labs.
7 This file is part of GCC.
9 GCC is free software; you can redistribute it and/or modify it
10 under the terms of the GNU General Public License as published by the
11 Free Software Foundation; either version 3, or (at your option) any
14 GCC is distributed in the hope that it will be useful, but WITHOUT
15 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
16 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING3. If not see
21 <http://www.gnu.org/licenses/>. */
23 /* Dead code elimination.
27 Building an Optimizing Compiler,
28 Robert Morgan, Butterworth-Heinemann, 1998, Section 8.9.
30 Advanced Compiler Design and Implementation,
31 Steven Muchnick, Morgan Kaufmann, 1997, Section 18.10.
33 Dead-code elimination is the removal of statements which have no
34 impact on the program's output. "Dead statements" have no impact
35 on the program's output, while "necessary statements" may have
38 The algorithm consists of three phases:
39 1. Marking as necessary all statements known to be necessary,
40 e.g. most function calls, writing a value to memory, etc;
41 2. Propagating necessary statements, e.g., the statements
42 giving values to operands in necessary statements; and
43 3. Removing dead statements. */
47 #include "coretypes.h"
52 #include "gimple-pretty-print.h"
58 #include "hard-reg-set.h"
61 #include "dominance.h"
64 #include "basic-block.h"
65 #include "tree-ssa-alias.h"
66 #include "internal-fn.h"
68 #include "gimple-expr.h"
72 #include "gimple-iterator.h"
73 #include "gimple-ssa.h"
75 #include "tree-phinodes.h"
76 #include "ssa-iterators.h"
77 #include "stringpool.h"
78 #include "tree-ssanames.h"
79 #include "tree-ssa-loop-niter.h"
80 #include "tree-into-ssa.h"
83 #include "tree-pass.h"
86 #include "tree-scalar-evolution.h"
87 #include "tree-chkp.h"
89 static struct stmt_stats
97 #define STMT_NECESSARY GF_PLF_1
99 static vec
<gimple
> worklist
;
101 /* Vector indicating an SSA name has already been processed and marked
103 static sbitmap processed
;
105 /* Vector indicating that the last statement of a basic block has already
106 been marked as necessary. */
107 static sbitmap last_stmt_necessary
;
109 /* Vector indicating that BB contains statements that are live. */
110 static sbitmap bb_contains_live_stmts
;
112 /* Before we can determine whether a control branch is dead, we need to
113 compute which blocks are control dependent on which edges.
115 We expect each block to be control dependent on very few edges so we
116 use a bitmap for each block recording its edges. An array holds the
117 bitmap. The Ith bit in the bitmap is set if that block is dependent
119 static control_dependences
*cd
;
121 /* Vector indicating that a basic block has already had all the edges
122 processed that it is control dependent on. */
123 static sbitmap visited_control_parents
;
125 /* TRUE if this pass alters the CFG (by removing control statements).
128 If this pass alters the CFG, then it will arrange for the dominators
130 static bool cfg_altered
;
133 /* If STMT is not already marked necessary, mark it, and add it to the
134 worklist if ADD_TO_WORKLIST is true. */
137 mark_stmt_necessary (gimple stmt
, bool add_to_worklist
)
141 if (gimple_plf (stmt
, STMT_NECESSARY
))
144 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
146 fprintf (dump_file
, "Marking useful stmt: ");
147 print_gimple_stmt (dump_file
, stmt
, 0, TDF_SLIM
);
148 fprintf (dump_file
, "\n");
151 gimple_set_plf (stmt
, STMT_NECESSARY
, true);
153 worklist
.safe_push (stmt
);
154 if (bb_contains_live_stmts
&& !is_gimple_debug (stmt
))
155 bitmap_set_bit (bb_contains_live_stmts
, gimple_bb (stmt
)->index
);
159 /* Mark the statement defining operand OP as necessary. */
162 mark_operand_necessary (tree op
)
169 ver
= SSA_NAME_VERSION (op
);
170 if (bitmap_bit_p (processed
, ver
))
172 stmt
= SSA_NAME_DEF_STMT (op
);
173 gcc_assert (gimple_nop_p (stmt
)
174 || gimple_plf (stmt
, STMT_NECESSARY
));
177 bitmap_set_bit (processed
, ver
);
179 stmt
= SSA_NAME_DEF_STMT (op
);
182 if (gimple_plf (stmt
, STMT_NECESSARY
) || gimple_nop_p (stmt
))
185 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
187 fprintf (dump_file
, "marking necessary through ");
188 print_generic_expr (dump_file
, op
, 0);
189 fprintf (dump_file
, " stmt ");
190 print_gimple_stmt (dump_file
, stmt
, 0, 0);
193 gimple_set_plf (stmt
, STMT_NECESSARY
, true);
194 if (bb_contains_live_stmts
)
195 bitmap_set_bit (bb_contains_live_stmts
, gimple_bb (stmt
)->index
);
196 worklist
.safe_push (stmt
);
200 /* Mark STMT as necessary if it obviously is. Add it to the worklist if
201 it can make other statements necessary.
203 If AGGRESSIVE is false, control statements are conservatively marked as
207 mark_stmt_if_obviously_necessary (gimple stmt
, bool aggressive
)
209 /* With non-call exceptions, we have to assume that all statements could
210 throw. If a statement could throw, it can be deemed necessary. */
211 if (cfun
->can_throw_non_call_exceptions
212 && !cfun
->can_delete_dead_exceptions
213 && stmt_could_throw_p (stmt
))
215 mark_stmt_necessary (stmt
, true);
219 /* Statements that are implicitly live. Most function calls, asm
220 and return statements are required. Labels and GIMPLE_BIND nodes
221 are kept because they are control flow, and we have no way of
222 knowing whether they can be removed. DCE can eliminate all the
223 other statements in a block, and CFG can then remove the block
225 switch (gimple_code (stmt
))
229 mark_stmt_necessary (stmt
, false);
235 mark_stmt_necessary (stmt
, true);
240 tree callee
= gimple_call_fndecl (stmt
);
241 if (callee
!= NULL_TREE
242 && DECL_BUILT_IN_CLASS (callee
) == BUILT_IN_NORMAL
)
243 switch (DECL_FUNCTION_CODE (callee
))
245 case BUILT_IN_MALLOC
:
246 case BUILT_IN_ALIGNED_ALLOC
:
247 case BUILT_IN_CALLOC
:
248 case BUILT_IN_ALLOCA
:
249 case BUILT_IN_ALLOCA_WITH_ALIGN
:
254 /* Most, but not all function calls are required. Function calls that
255 produce no result and have no side effects (i.e. const pure
256 functions) are unnecessary. */
257 if (gimple_has_side_effects (stmt
))
259 mark_stmt_necessary (stmt
, true);
262 if (!gimple_call_lhs (stmt
))
268 /* Debug temps without a value are not useful. ??? If we could
269 easily locate the debug temp bind stmt for a use thereof,
270 would could refrain from marking all debug temps here, and
271 mark them only if they're used. */
272 if (!gimple_debug_bind_p (stmt
)
273 || gimple_debug_bind_has_value_p (stmt
)
274 || TREE_CODE (gimple_debug_bind_get_var (stmt
)) != DEBUG_EXPR_DECL
)
275 mark_stmt_necessary (stmt
, false);
279 gcc_assert (!simple_goto_p (stmt
));
280 mark_stmt_necessary (stmt
, true);
284 gcc_assert (EDGE_COUNT (gimple_bb (stmt
)->succs
) == 2);
289 mark_stmt_necessary (stmt
, true);
293 if (TREE_CODE (gimple_assign_lhs (stmt
)) == SSA_NAME
294 && TREE_CLOBBER_P (gimple_assign_rhs1 (stmt
)))
302 /* If the statement has volatile operands, it needs to be preserved.
303 Same for statements that can alter control flow in unpredictable
305 if (gimple_has_volatile_ops (stmt
) || is_ctrl_altering_stmt (stmt
))
307 mark_stmt_necessary (stmt
, true);
311 if (stmt_may_clobber_global_p (stmt
))
313 mark_stmt_necessary (stmt
, true);
321 /* Mark the last statement of BB as necessary. */
324 mark_last_stmt_necessary (basic_block bb
)
326 gimple stmt
= last_stmt (bb
);
328 bitmap_set_bit (last_stmt_necessary
, bb
->index
);
329 bitmap_set_bit (bb_contains_live_stmts
, bb
->index
);
331 /* We actually mark the statement only if it is a control statement. */
332 if (stmt
&& is_ctrl_stmt (stmt
))
333 mark_stmt_necessary (stmt
, true);
337 /* Mark control dependent edges of BB as necessary. We have to do this only
338 once for each basic block so we set the appropriate bit after we're done.
340 When IGNORE_SELF is true, ignore BB in the list of control dependences. */
343 mark_control_dependent_edges_necessary (basic_block bb
, bool ignore_self
)
346 unsigned edge_number
;
347 bool skipped
= false;
349 gcc_assert (bb
!= EXIT_BLOCK_PTR_FOR_FN (cfun
));
351 if (bb
== ENTRY_BLOCK_PTR_FOR_FN (cfun
))
354 EXECUTE_IF_SET_IN_BITMAP (cd
->get_edges_dependent_on (bb
->index
),
357 basic_block cd_bb
= cd
->get_edge (edge_number
)->src
;
359 if (ignore_self
&& cd_bb
== bb
)
365 if (!bitmap_bit_p (last_stmt_necessary
, cd_bb
->index
))
366 mark_last_stmt_necessary (cd_bb
);
370 bitmap_set_bit (visited_control_parents
, bb
->index
);
374 /* Find obviously necessary statements. These are things like most function
375 calls, and stores to file level variables.
377 If EL is NULL, control statements are conservatively marked as
378 necessary. Otherwise it contains the list of edges used by control
379 dependence analysis. */
382 find_obviously_necessary_stmts (bool aggressive
)
385 gimple_stmt_iterator gsi
;
390 FOR_EACH_BB_FN (bb
, cfun
)
392 /* PHI nodes are never inherently necessary. */
393 for (gsi
= gsi_start_phis (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
395 phi
= gsi_stmt (gsi
);
396 gimple_set_plf (phi
, STMT_NECESSARY
, false);
399 /* Check all statements in the block. */
400 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
402 stmt
= gsi_stmt (gsi
);
403 gimple_set_plf (stmt
, STMT_NECESSARY
, false);
404 mark_stmt_if_obviously_necessary (stmt
, aggressive
);
408 /* Pure and const functions are finite and thus have no infinite loops in
410 flags
= flags_from_decl_or_type (current_function_decl
);
411 if ((flags
& (ECF_CONST
|ECF_PURE
)) && !(flags
& ECF_LOOPING_CONST_OR_PURE
))
414 /* Prevent the empty possibly infinite loops from being removed. */
419 if (mark_irreducible_loops ())
420 FOR_EACH_BB_FN (bb
, cfun
)
423 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
424 if ((e
->flags
& EDGE_DFS_BACK
)
425 && (e
->flags
& EDGE_IRREDUCIBLE_LOOP
))
428 fprintf (dump_file
, "Marking back edge of irreducible loop %i->%i\n",
429 e
->src
->index
, e
->dest
->index
);
430 mark_control_dependent_edges_necessary (e
->dest
, false);
434 FOR_EACH_LOOP (loop
, 0)
435 if (!finite_loop_p (loop
))
438 fprintf (dump_file
, "can not prove finiteness of loop %i\n", loop
->num
);
439 mark_control_dependent_edges_necessary (loop
->latch
, false);
446 /* Return true if REF is based on an aliased base, otherwise false. */
449 ref_may_be_aliased (tree ref
)
451 gcc_assert (TREE_CODE (ref
) != WITH_SIZE_EXPR
);
452 while (handled_component_p (ref
))
453 ref
= TREE_OPERAND (ref
, 0);
454 if (TREE_CODE (ref
) == MEM_REF
455 && TREE_CODE (TREE_OPERAND (ref
, 0)) == ADDR_EXPR
)
456 ref
= TREE_OPERAND (TREE_OPERAND (ref
, 0), 0);
457 return !(DECL_P (ref
)
458 && !may_be_aliased (ref
));
461 static bitmap visited
= NULL
;
462 static unsigned int longest_chain
= 0;
463 static unsigned int total_chain
= 0;
464 static unsigned int nr_walks
= 0;
465 static bool chain_ovfl
= false;
467 /* Worker for the walker that marks reaching definitions of REF,
468 which is based on a non-aliased decl, necessary. It returns
469 true whenever the defining statement of the current VDEF is
470 a kill for REF, as no dominating may-defs are necessary for REF
471 anymore. DATA points to the basic-block that contains the
472 stmt that refers to REF. */
475 mark_aliased_reaching_defs_necessary_1 (ao_ref
*ref
, tree vdef
, void *data
)
477 gimple def_stmt
= SSA_NAME_DEF_STMT (vdef
);
479 /* All stmts we visit are necessary. */
480 mark_operand_necessary (vdef
);
482 /* If the stmt lhs kills ref, then we can stop walking. */
483 if (gimple_has_lhs (def_stmt
)
484 && TREE_CODE (gimple_get_lhs (def_stmt
)) != SSA_NAME
485 /* The assignment is not necessarily carried out if it can throw
486 and we can catch it in the current function where we could inspect
488 ??? We only need to care about the RHS throwing. For aggregate
489 assignments or similar calls and non-call exceptions the LHS
490 might throw as well. */
491 && !stmt_can_throw_internal (def_stmt
))
493 tree base
, lhs
= gimple_get_lhs (def_stmt
);
494 HOST_WIDE_INT size
, offset
, max_size
;
496 base
= get_ref_base_and_extent (lhs
, &offset
, &size
, &max_size
);
497 /* We can get MEM[symbol: sZ, index: D.8862_1] here,
498 so base == refd->base does not always hold. */
499 if (base
== ref
->base
)
501 /* For a must-alias check we need to be able to constrain
502 the accesses properly. */
503 if (size
!= -1 && size
== max_size
504 && ref
->max_size
!= -1)
506 if (offset
<= ref
->offset
507 && offset
+ size
>= ref
->offset
+ ref
->max_size
)
510 /* Or they need to be exactly the same. */
512 /* Make sure there is no induction variable involved
513 in the references (gcc.c-torture/execute/pr42142.c).
514 The simplest way is to check if the kill dominates
516 /* But when both are in the same block we cannot
517 easily tell whether we came from a backedge
518 unless we decide to compute stmt UIDs
520 && (basic_block
) data
!= gimple_bb (def_stmt
)
521 && dominated_by_p (CDI_DOMINATORS
, (basic_block
) data
,
522 gimple_bb (def_stmt
))
523 && operand_equal_p (ref
->ref
, lhs
, 0))
528 /* Otherwise keep walking. */
533 mark_aliased_reaching_defs_necessary (gimple stmt
, tree ref
)
537 gcc_assert (!chain_ovfl
);
538 ao_ref_init (&refd
, ref
);
539 chain
= walk_aliased_vdefs (&refd
, gimple_vuse (stmt
),
540 mark_aliased_reaching_defs_necessary_1
,
541 gimple_bb (stmt
), NULL
);
542 if (chain
> longest_chain
)
543 longest_chain
= chain
;
544 total_chain
+= chain
;
548 /* Worker for the walker that marks reaching definitions of REF, which
549 is not based on a non-aliased decl. For simplicity we need to end
550 up marking all may-defs necessary that are not based on a non-aliased
551 decl. The only job of this walker is to skip may-defs based on
552 a non-aliased decl. */
555 mark_all_reaching_defs_necessary_1 (ao_ref
*ref ATTRIBUTE_UNUSED
,
556 tree vdef
, void *data ATTRIBUTE_UNUSED
)
558 gimple def_stmt
= SSA_NAME_DEF_STMT (vdef
);
560 /* We have to skip already visited (and thus necessary) statements
561 to make the chaining work after we dropped back to simple mode. */
563 && bitmap_bit_p (processed
, SSA_NAME_VERSION (vdef
)))
565 gcc_assert (gimple_nop_p (def_stmt
)
566 || gimple_plf (def_stmt
, STMT_NECESSARY
));
570 /* We want to skip stores to non-aliased variables. */
572 && gimple_assign_single_p (def_stmt
))
574 tree lhs
= gimple_assign_lhs (def_stmt
);
575 if (!ref_may_be_aliased (lhs
))
579 /* We want to skip statments that do not constitute stores but have
580 a virtual definition. */
581 if (is_gimple_call (def_stmt
))
583 tree callee
= gimple_call_fndecl (def_stmt
);
584 if (callee
!= NULL_TREE
585 && DECL_BUILT_IN_CLASS (callee
) == BUILT_IN_NORMAL
)
586 switch (DECL_FUNCTION_CODE (callee
))
588 case BUILT_IN_MALLOC
:
589 case BUILT_IN_ALIGNED_ALLOC
:
590 case BUILT_IN_CALLOC
:
591 case BUILT_IN_ALLOCA
:
592 case BUILT_IN_ALLOCA_WITH_ALIGN
:
600 mark_operand_necessary (vdef
);
606 mark_all_reaching_defs_necessary (gimple stmt
)
608 walk_aliased_vdefs (NULL
, gimple_vuse (stmt
),
609 mark_all_reaching_defs_necessary_1
, NULL
, &visited
);
612 /* Return true for PHI nodes with one or identical arguments
615 degenerate_phi_p (gimple phi
)
618 tree op
= gimple_phi_arg_def (phi
, 0);
619 for (i
= 1; i
< gimple_phi_num_args (phi
); i
++)
620 if (gimple_phi_arg_def (phi
, i
) != op
)
625 /* Propagate necessity using the operands of necessary statements.
626 Process the uses on each statement in the worklist, and add all
627 feeding statements which contribute to the calculation of this
628 value to the worklist.
630 In conservative mode, EL is NULL. */
633 propagate_necessity (bool aggressive
)
637 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
638 fprintf (dump_file
, "\nProcessing worklist:\n");
640 while (worklist
.length () > 0)
642 /* Take STMT from worklist. */
643 stmt
= worklist
.pop ();
645 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
647 fprintf (dump_file
, "processing: ");
648 print_gimple_stmt (dump_file
, stmt
, 0, TDF_SLIM
);
649 fprintf (dump_file
, "\n");
654 /* Mark the last statement of the basic blocks on which the block
655 containing STMT is control dependent, but only if we haven't
657 basic_block bb
= gimple_bb (stmt
);
658 if (bb
!= ENTRY_BLOCK_PTR_FOR_FN (cfun
)
659 && !bitmap_bit_p (visited_control_parents
, bb
->index
))
660 mark_control_dependent_edges_necessary (bb
, false);
663 if (gimple_code (stmt
) == GIMPLE_PHI
664 /* We do not process virtual PHI nodes nor do we track their
666 && !virtual_operand_p (gimple_phi_result (stmt
)))
668 /* PHI nodes are somewhat special in that each PHI alternative has
669 data and control dependencies. All the statements feeding the
670 PHI node's arguments are always necessary. In aggressive mode,
671 we also consider the control dependent edges leading to the
672 predecessor block associated with each PHI alternative as
676 for (k
= 0; k
< gimple_phi_num_args (stmt
); k
++)
678 tree arg
= PHI_ARG_DEF (stmt
, k
);
679 if (TREE_CODE (arg
) == SSA_NAME
)
680 mark_operand_necessary (arg
);
683 /* For PHI operands it matters from where the control flow arrives
684 to the BB. Consider the following example:
694 We need to mark control dependence of the empty basic blocks, since they
695 contains computation of PHI operands.
697 Doing so is too restrictive in the case the predecestor block is in
703 for (i = 0; i<1000; ++i)
709 There is PHI for J in the BB containing return statement.
710 In this case the control dependence of predecestor block (that is
711 within the empty loop) also contains the block determining number
712 of iterations of the block that would prevent removing of empty
715 This scenario can be avoided by splitting critical edges.
716 To save the critical edge splitting pass we identify how the control
717 dependence would look like if the edge was split.
719 Consider the modified CFG created from current CFG by splitting
720 edge B->C. In the postdominance tree of modified CFG, C' is
721 always child of C. There are two cases how chlids of C' can look
726 In this case the only basic block C' is control dependent on is B.
728 2) C' has single child that is B
730 In this case control dependence of C' is same as control
731 dependence of B in original CFG except for block B itself.
732 (since C' postdominate B in modified CFG)
734 Now how to decide what case happens? There are two basic options:
736 a) C postdominate B. Then C immediately postdominate B and
737 case 2 happens iff there is no other way from B to C except
740 There is other way from B to C iff there is succesor of B that
741 is not postdominated by B. Testing this condition is somewhat
742 expensive, because we need to iterate all succesors of B.
743 We are safe to assume that this does not happen: we will mark B
744 as needed when processing the other path from B to C that is
745 conrol dependent on B and marking control dependencies of B
746 itself is harmless because they will be processed anyway after
747 processing control statement in B.
749 b) C does not postdominate B. Always case 1 happens since there is
750 path from C to exit that does not go through B and thus also C'. */
752 if (aggressive
&& !degenerate_phi_p (stmt
))
754 for (k
= 0; k
< gimple_phi_num_args (stmt
); k
++)
756 basic_block arg_bb
= gimple_phi_arg_edge (stmt
, k
)->src
;
759 != get_immediate_dominator (CDI_POST_DOMINATORS
, arg_bb
))
761 if (!bitmap_bit_p (last_stmt_necessary
, arg_bb
->index
))
762 mark_last_stmt_necessary (arg_bb
);
764 else if (arg_bb
!= ENTRY_BLOCK_PTR_FOR_FN (cfun
)
765 && !bitmap_bit_p (visited_control_parents
,
767 mark_control_dependent_edges_necessary (arg_bb
, true);
773 /* Propagate through the operands. Examine all the USE, VUSE and
774 VDEF operands in this statement. Mark all the statements
775 which feed this statement's uses as necessary. */
779 /* If this is a call to free which is directly fed by an
780 allocation function do not mark that necessary through
781 processing the argument. */
782 if (gimple_call_builtin_p (stmt
, BUILT_IN_FREE
))
784 tree ptr
= gimple_call_arg (stmt
, 0);
787 /* If the pointer we free is defined by an allocation
788 function do not add the call to the worklist. */
789 if (TREE_CODE (ptr
) == SSA_NAME
790 && is_gimple_call (def_stmt
= SSA_NAME_DEF_STMT (ptr
))
791 && (def_callee
= gimple_call_fndecl (def_stmt
))
792 && DECL_BUILT_IN_CLASS (def_callee
) == BUILT_IN_NORMAL
793 && (DECL_FUNCTION_CODE (def_callee
) == BUILT_IN_ALIGNED_ALLOC
794 || DECL_FUNCTION_CODE (def_callee
) == BUILT_IN_MALLOC
795 || DECL_FUNCTION_CODE (def_callee
) == BUILT_IN_CALLOC
))
797 gimple bounds_def_stmt
;
800 /* For instrumented calls we should also check used
801 bounds are returned by the same allocation call. */
802 if (!gimple_call_with_bounds_p (stmt
)
803 || ((bounds
= gimple_call_arg (stmt
, 1))
804 && TREE_CODE (bounds
) == SSA_NAME
805 && (bounds_def_stmt
= SSA_NAME_DEF_STMT (bounds
))
806 && chkp_gimple_call_builtin_p (bounds_def_stmt
,
807 BUILT_IN_CHKP_BNDRET
)
808 && gimple_call_arg (bounds_def_stmt
, 0) == ptr
))
813 FOR_EACH_SSA_TREE_OPERAND (use
, stmt
, iter
, SSA_OP_USE
)
814 mark_operand_necessary (use
);
816 use
= gimple_vuse (stmt
);
820 /* If we dropped to simple mode make all immediately
821 reachable definitions necessary. */
824 mark_all_reaching_defs_necessary (stmt
);
828 /* For statements that may load from memory (have a VUSE) we
829 have to mark all reaching (may-)definitions as necessary.
830 We partition this task into two cases:
831 1) explicit loads based on decls that are not aliased
832 2) implicit loads (like calls) and explicit loads not
833 based on decls that are not aliased (like indirect
834 references or loads from globals)
835 For 1) we mark all reaching may-defs as necessary, stopping
836 at dominating kills. For 2) we want to mark all dominating
837 references necessary, but non-aliased ones which we handle
838 in 1). By keeping a global visited bitmap for references
839 we walk for 2) we avoid quadratic behavior for those. */
841 if (is_gimple_call (stmt
))
843 tree callee
= gimple_call_fndecl (stmt
);
846 /* Calls to functions that are merely acting as barriers
847 or that only store to memory do not make any previous
849 if (callee
!= NULL_TREE
850 && DECL_BUILT_IN_CLASS (callee
) == BUILT_IN_NORMAL
851 && (DECL_FUNCTION_CODE (callee
) == BUILT_IN_MEMSET
852 || DECL_FUNCTION_CODE (callee
) == BUILT_IN_MEMSET_CHK
853 || DECL_FUNCTION_CODE (callee
) == BUILT_IN_MALLOC
854 || DECL_FUNCTION_CODE (callee
) == BUILT_IN_ALIGNED_ALLOC
855 || DECL_FUNCTION_CODE (callee
) == BUILT_IN_CALLOC
856 || DECL_FUNCTION_CODE (callee
) == BUILT_IN_FREE
857 || DECL_FUNCTION_CODE (callee
) == BUILT_IN_VA_END
858 || DECL_FUNCTION_CODE (callee
) == BUILT_IN_ALLOCA
859 || (DECL_FUNCTION_CODE (callee
)
860 == BUILT_IN_ALLOCA_WITH_ALIGN
)
861 || DECL_FUNCTION_CODE (callee
) == BUILT_IN_STACK_SAVE
862 || DECL_FUNCTION_CODE (callee
) == BUILT_IN_STACK_RESTORE
863 || DECL_FUNCTION_CODE (callee
) == BUILT_IN_ASSUME_ALIGNED
))
866 /* Calls implicitly load from memory, their arguments
867 in addition may explicitly perform memory loads. */
868 mark_all_reaching_defs_necessary (stmt
);
869 for (i
= 0; i
< gimple_call_num_args (stmt
); ++i
)
871 tree arg
= gimple_call_arg (stmt
, i
);
872 if (TREE_CODE (arg
) == SSA_NAME
873 || is_gimple_min_invariant (arg
))
875 if (TREE_CODE (arg
) == WITH_SIZE_EXPR
)
876 arg
= TREE_OPERAND (arg
, 0);
877 if (!ref_may_be_aliased (arg
))
878 mark_aliased_reaching_defs_necessary (stmt
, arg
);
881 else if (gimple_assign_single_p (stmt
))
884 /* If this is a load mark things necessary. */
885 rhs
= gimple_assign_rhs1 (stmt
);
886 if (TREE_CODE (rhs
) != SSA_NAME
887 && !is_gimple_min_invariant (rhs
)
888 && TREE_CODE (rhs
) != CONSTRUCTOR
)
890 if (!ref_may_be_aliased (rhs
))
891 mark_aliased_reaching_defs_necessary (stmt
, rhs
);
893 mark_all_reaching_defs_necessary (stmt
);
896 else if (gimple_code (stmt
) == GIMPLE_RETURN
)
898 tree rhs
= gimple_return_retval (stmt
);
899 /* A return statement may perform a load. */
901 && TREE_CODE (rhs
) != SSA_NAME
902 && !is_gimple_min_invariant (rhs
)
903 && TREE_CODE (rhs
) != CONSTRUCTOR
)
905 if (!ref_may_be_aliased (rhs
))
906 mark_aliased_reaching_defs_necessary (stmt
, rhs
);
908 mark_all_reaching_defs_necessary (stmt
);
911 else if (gimple_code (stmt
) == GIMPLE_ASM
)
914 mark_all_reaching_defs_necessary (stmt
);
915 /* Inputs may perform loads. */
916 for (i
= 0; i
< gimple_asm_ninputs (stmt
); ++i
)
918 tree op
= TREE_VALUE (gimple_asm_input_op (stmt
, i
));
919 if (TREE_CODE (op
) != SSA_NAME
920 && !is_gimple_min_invariant (op
)
921 && TREE_CODE (op
) != CONSTRUCTOR
922 && !ref_may_be_aliased (op
))
923 mark_aliased_reaching_defs_necessary (stmt
, op
);
926 else if (gimple_code (stmt
) == GIMPLE_TRANSACTION
)
928 /* The beginning of a transaction is a memory barrier. */
929 /* ??? If we were really cool, we'd only be a barrier
930 for the memories touched within the transaction. */
931 mark_all_reaching_defs_necessary (stmt
);
936 /* If we over-used our alias oracle budget drop to simple
937 mode. The cost metric allows quadratic behavior
938 (number of uses times number of may-defs queries) up to
939 a constant maximal number of queries and after that falls back to
940 super-linear complexity. */
941 if (/* Constant but quadratic for small functions. */
942 total_chain
> 128 * 128
943 /* Linear in the number of may-defs. */
944 && total_chain
> 32 * longest_chain
945 /* Linear in the number of uses. */
946 && total_chain
> nr_walks
* 32)
950 bitmap_clear (visited
);
956 /* Remove dead PHI nodes from block BB. */
959 remove_dead_phis (basic_block bb
)
961 bool something_changed
= false;
963 gimple_stmt_iterator gsi
;
965 for (gsi
= gsi_start_phis (bb
); !gsi_end_p (gsi
);)
968 phi
= gsi_stmt (gsi
);
970 /* We do not track necessity of virtual PHI nodes. Instead do
971 very simple dead PHI removal here. */
972 if (virtual_operand_p (gimple_phi_result (phi
)))
974 /* Virtual PHI nodes with one or identical arguments
976 if (degenerate_phi_p (phi
))
978 tree vdef
= gimple_phi_result (phi
);
979 tree vuse
= gimple_phi_arg_def (phi
, 0);
982 imm_use_iterator iter
;
984 FOR_EACH_IMM_USE_STMT (use_stmt
, iter
, vdef
)
985 FOR_EACH_IMM_USE_ON_STMT (use_p
, iter
)
986 SET_USE (use_p
, vuse
);
987 if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (vdef
)
988 && TREE_CODE (vuse
) == SSA_NAME
)
989 SSA_NAME_OCCURS_IN_ABNORMAL_PHI (vuse
) = 1;
992 gimple_set_plf (phi
, STMT_NECESSARY
, true);
995 if (!gimple_plf (phi
, STMT_NECESSARY
))
997 something_changed
= true;
998 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1000 fprintf (dump_file
, "Deleting : ");
1001 print_gimple_stmt (dump_file
, phi
, 0, TDF_SLIM
);
1002 fprintf (dump_file
, "\n");
1005 remove_phi_node (&gsi
, true);
1006 stats
.removed_phis
++;
1012 return something_changed
;
1015 /* Forward edge E to respective POST_DOM_BB and update PHIs. */
1018 forward_edge_to_pdom (edge e
, basic_block post_dom_bb
)
1020 gimple_stmt_iterator gsi
;
1024 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1025 fprintf (dump_file
, "Redirecting edge %i->%i to %i\n", e
->src
->index
,
1026 e
->dest
->index
, post_dom_bb
->index
);
1028 e2
= redirect_edge_and_branch (e
, post_dom_bb
);
1031 /* If edge was already around, no updating is necessary. */
1035 if (!gimple_seq_empty_p (phi_nodes (post_dom_bb
)))
1037 /* We are sure that for every live PHI we are seeing control dependent BB.
1038 This means that we can pick any edge to duplicate PHI args from. */
1039 FOR_EACH_EDGE (e2
, ei
, post_dom_bb
->preds
)
1042 for (gsi
= gsi_start_phis (post_dom_bb
); !gsi_end_p (gsi
);)
1044 gimple phi
= gsi_stmt (gsi
);
1046 source_location locus
;
1048 /* PHIs for virtuals have no control dependency relation on them.
1049 We are lost here and must force renaming of the symbol. */
1050 if (virtual_operand_p (gimple_phi_result (phi
)))
1052 mark_virtual_phi_result_for_renaming (phi
);
1053 remove_phi_node (&gsi
, true);
1057 /* Dead PHI do not imply control dependency. */
1058 if (!gimple_plf (phi
, STMT_NECESSARY
))
1064 op
= gimple_phi_arg_def (phi
, e2
->dest_idx
);
1065 locus
= gimple_phi_arg_location (phi
, e2
->dest_idx
);
1066 add_phi_arg (phi
, op
, e
, locus
);
1067 /* The resulting PHI if not dead can only be degenerate. */
1068 gcc_assert (degenerate_phi_p (phi
));
1075 /* Remove dead statement pointed to by iterator I. Receives the basic block BB
1076 containing I so that we don't have to look it up. */
1079 remove_dead_stmt (gimple_stmt_iterator
*i
, basic_block bb
)
1081 gimple stmt
= gsi_stmt (*i
);
1083 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1085 fprintf (dump_file
, "Deleting : ");
1086 print_gimple_stmt (dump_file
, stmt
, 0, TDF_SLIM
);
1087 fprintf (dump_file
, "\n");
1092 /* If we have determined that a conditional branch statement contributes
1093 nothing to the program, then we not only remove it, but we also change
1094 the flow graph so that the current block will simply fall-thru to its
1095 immediate post-dominator. The blocks we are circumventing will be
1096 removed by cleanup_tree_cfg if this change in the flow graph makes them
1098 if (is_ctrl_stmt (stmt
))
1100 basic_block post_dom_bb
;
1104 post_dom_bb
= get_immediate_dominator (CDI_POST_DOMINATORS
, bb
);
1106 e
= find_edge (bb
, post_dom_bb
);
1108 /* If edge is already there, try to use it. This avoids need to update
1109 PHI nodes. Also watch for cases where post dominator does not exists
1110 or is exit block. These can happen for infinite loops as we create
1111 fake edges in the dominator tree. */
1114 else if (! post_dom_bb
|| post_dom_bb
== EXIT_BLOCK_PTR_FOR_FN (cfun
))
1115 e
= EDGE_SUCC (bb
, 0);
1117 e
= forward_edge_to_pdom (EDGE_SUCC (bb
, 0), post_dom_bb
);
1119 e
->probability
= REG_BR_PROB_BASE
;
1120 e
->count
= bb
->count
;
1122 /* The edge is no longer associated with a conditional, so it does
1123 not have TRUE/FALSE flags. */
1124 e
->flags
&= ~(EDGE_TRUE_VALUE
| EDGE_FALSE_VALUE
);
1126 /* The lone outgoing edge from BB will be a fallthru edge. */
1127 e
->flags
|= EDGE_FALLTHRU
;
1129 /* Remove the remaining outgoing edges. */
1130 for (ei
= ei_start (bb
->succs
); (e2
= ei_safe_edge (ei
)); )
1140 /* If this is a store into a variable that is being optimized away,
1141 add a debug bind stmt if possible. */
1142 if (MAY_HAVE_DEBUG_STMTS
1143 && gimple_assign_single_p (stmt
)
1144 && is_gimple_val (gimple_assign_rhs1 (stmt
)))
1146 tree lhs
= gimple_assign_lhs (stmt
);
1147 if ((TREE_CODE (lhs
) == VAR_DECL
|| TREE_CODE (lhs
) == PARM_DECL
)
1148 && !DECL_IGNORED_P (lhs
)
1149 && is_gimple_reg_type (TREE_TYPE (lhs
))
1150 && !is_global_var (lhs
)
1151 && !DECL_HAS_VALUE_EXPR_P (lhs
))
1153 tree rhs
= gimple_assign_rhs1 (stmt
);
1155 = gimple_build_debug_bind (lhs
, unshare_expr (rhs
), stmt
);
1156 gsi_insert_after (i
, note
, GSI_SAME_STMT
);
1160 unlink_stmt_vdef (stmt
);
1161 gsi_remove (i
, true);
1162 release_defs (stmt
);
1165 /* Eliminate unnecessary statements. Any instruction not marked as necessary
1166 contributes nothing to the program, and can be deleted. */
1169 eliminate_unnecessary_stmts (void)
1171 bool something_changed
= false;
1173 gimple_stmt_iterator gsi
, psi
;
1178 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1179 fprintf (dump_file
, "\nEliminating unnecessary statements:\n");
1181 clear_special_calls ();
1183 /* Walking basic blocks and statements in reverse order avoids
1184 releasing SSA names before any other DEFs that refer to them are
1185 released. This helps avoid loss of debug information, as we get
1186 a chance to propagate all RHSs of removed SSAs into debug uses,
1187 rather than only the latest ones. E.g., consider:
1193 If we were to release x_3 before a_5, when we reached a_5 and
1194 tried to substitute it into the debug stmt, we'd see x_3 there,
1195 but x_3's DEF, type, etc would have already been disconnected.
1196 By going backwards, the debug stmt first changes to:
1198 # DEBUG a => x_3 - b_4
1202 # DEBUG a => y_1 + z_2 - b_4
1205 gcc_assert (dom_info_available_p (CDI_DOMINATORS
));
1206 h
= get_all_dominated_blocks (CDI_DOMINATORS
,
1207 single_succ (ENTRY_BLOCK_PTR_FOR_FN (cfun
)));
1213 /* Remove dead statements. */
1214 for (gsi
= gsi_last_bb (bb
); !gsi_end_p (gsi
); gsi
= psi
)
1216 stmt
= gsi_stmt (gsi
);
1223 /* We can mark a call to free as not necessary if the
1224 defining statement of its argument is not necessary
1225 (and thus is getting removed). */
1226 if (gimple_plf (stmt
, STMT_NECESSARY
)
1227 && gimple_call_builtin_p (stmt
, BUILT_IN_FREE
))
1229 tree ptr
= gimple_call_arg (stmt
, 0);
1230 if (TREE_CODE (ptr
) == SSA_NAME
)
1232 gimple def_stmt
= SSA_NAME_DEF_STMT (ptr
);
1233 if (!gimple_nop_p (def_stmt
)
1234 && !gimple_plf (def_stmt
, STMT_NECESSARY
))
1235 gimple_set_plf (stmt
, STMT_NECESSARY
, false);
1237 /* We did not propagate necessity for free calls fed
1238 by allocation function to allow unnecessary
1239 alloc-free sequence elimination. For instrumented
1240 calls it also means we did not mark bounds producer
1241 as necessary and it is time to do it in case free
1242 call is not removed. */
1243 if (gimple_call_with_bounds_p (stmt
))
1245 gimple bounds_def_stmt
;
1246 tree bounds
= gimple_call_arg (stmt
, 1);
1247 gcc_assert (TREE_CODE (bounds
) == SSA_NAME
);
1248 bounds_def_stmt
= SSA_NAME_DEF_STMT (bounds
);
1250 && !gimple_plf (bounds_def_stmt
, STMT_NECESSARY
))
1251 gimple_set_plf (bounds_def_stmt
, STMT_NECESSARY
,
1252 gimple_plf (stmt
, STMT_NECESSARY
));
1256 /* If GSI is not necessary then remove it. */
1257 if (!gimple_plf (stmt
, STMT_NECESSARY
))
1259 if (!is_gimple_debug (stmt
))
1260 something_changed
= true;
1261 remove_dead_stmt (&gsi
, bb
);
1263 else if (is_gimple_call (stmt
))
1265 tree name
= gimple_call_lhs (stmt
);
1267 notice_special_calls (stmt
);
1269 /* When LHS of var = call (); is dead, simplify it into
1270 call (); saving one operand. */
1272 && TREE_CODE (name
) == SSA_NAME
1273 && !bitmap_bit_p (processed
, SSA_NAME_VERSION (name
))
1274 /* Avoid doing so for allocation calls which we
1275 did not mark as necessary, it will confuse the
1276 special logic we apply to malloc/free pair removal. */
1277 && (!(call
= gimple_call_fndecl (stmt
))
1278 || DECL_BUILT_IN_CLASS (call
) != BUILT_IN_NORMAL
1279 || (DECL_FUNCTION_CODE (call
) != BUILT_IN_ALIGNED_ALLOC
1280 && DECL_FUNCTION_CODE (call
) != BUILT_IN_MALLOC
1281 && DECL_FUNCTION_CODE (call
) != BUILT_IN_CALLOC
1282 && DECL_FUNCTION_CODE (call
) != BUILT_IN_ALLOCA
1283 && (DECL_FUNCTION_CODE (call
)
1284 != BUILT_IN_ALLOCA_WITH_ALIGN
)))
1285 /* Avoid doing so for bndret calls for the same reason. */
1286 && !chkp_gimple_call_builtin_p (stmt
, BUILT_IN_CHKP_BNDRET
))
1288 something_changed
= true;
1289 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1291 fprintf (dump_file
, "Deleting LHS of call: ");
1292 print_gimple_stmt (dump_file
, stmt
, 0, TDF_SLIM
);
1293 fprintf (dump_file
, "\n");
1296 gimple_call_set_lhs (stmt
, NULL_TREE
);
1297 maybe_clean_or_replace_eh_stmt (stmt
, stmt
);
1299 release_ssa_name (name
);
1307 /* Since we don't track liveness of virtual PHI nodes, it is possible that we
1308 rendered some PHI nodes unreachable while they are still in use.
1309 Mark them for renaming. */
1312 basic_block prev_bb
;
1314 find_unreachable_blocks ();
1316 /* Delete all unreachable basic blocks in reverse dominator order. */
1317 for (bb
= EXIT_BLOCK_PTR_FOR_FN (cfun
)->prev_bb
;
1318 bb
!= ENTRY_BLOCK_PTR_FOR_FN (cfun
); bb
= prev_bb
)
1320 prev_bb
= bb
->prev_bb
;
1322 if (!bitmap_bit_p (bb_contains_live_stmts
, bb
->index
)
1323 || !(bb
->flags
& BB_REACHABLE
))
1325 for (gsi
= gsi_start_phis (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1326 if (virtual_operand_p (gimple_phi_result (gsi_stmt (gsi
))))
1329 imm_use_iterator iter
;
1331 FOR_EACH_IMM_USE_STMT (stmt
, iter
, gimple_phi_result (gsi_stmt (gsi
)))
1333 if (!(gimple_bb (stmt
)->flags
& BB_REACHABLE
))
1335 if (gimple_code (stmt
) == GIMPLE_PHI
1336 || gimple_plf (stmt
, STMT_NECESSARY
))
1339 BREAK_FROM_IMM_USE_STMT (iter
);
1343 mark_virtual_phi_result_for_renaming (gsi_stmt (gsi
));
1346 if (!(bb
->flags
& BB_REACHABLE
))
1348 /* Speed up the removal of blocks that don't
1349 dominate others. Walking backwards, this should
1350 be the common case. ??? Do we need to recompute
1351 dominators because of cfg_altered? */
1352 if (!MAY_HAVE_DEBUG_STMTS
1353 || !first_dom_son (CDI_DOMINATORS
, bb
))
1354 delete_basic_block (bb
);
1357 h
= get_all_dominated_blocks (CDI_DOMINATORS
, bb
);
1362 prev_bb
= bb
->prev_bb
;
1363 /* Rearrangements to the CFG may have failed
1364 to update the dominators tree, so that
1365 formerly-dominated blocks are now
1366 otherwise reachable. */
1367 if (!!(bb
->flags
& BB_REACHABLE
))
1369 delete_basic_block (bb
);
1378 FOR_EACH_BB_FN (bb
, cfun
)
1380 /* Remove dead PHI nodes. */
1381 something_changed
|= remove_dead_phis (bb
);
1384 return something_changed
;
1388 /* Print out removed statement statistics. */
1395 percg
= ((float) stats
.removed
/ (float) stats
.total
) * 100;
1396 fprintf (dump_file
, "Removed %d of %d statements (%d%%)\n",
1397 stats
.removed
, stats
.total
, (int) percg
);
1399 if (stats
.total_phis
== 0)
1402 percg
= ((float) stats
.removed_phis
/ (float) stats
.total_phis
) * 100;
1404 fprintf (dump_file
, "Removed %d of %d PHI nodes (%d%%)\n",
1405 stats
.removed_phis
, stats
.total_phis
, (int) percg
);
1408 /* Initialization for this pass. Set up the used data structures. */
1411 tree_dce_init (bool aggressive
)
1413 memset ((void *) &stats
, 0, sizeof (stats
));
1417 last_stmt_necessary
= sbitmap_alloc (last_basic_block_for_fn (cfun
));
1418 bitmap_clear (last_stmt_necessary
);
1419 bb_contains_live_stmts
= sbitmap_alloc (last_basic_block_for_fn (cfun
));
1420 bitmap_clear (bb_contains_live_stmts
);
1423 processed
= sbitmap_alloc (num_ssa_names
+ 1);
1424 bitmap_clear (processed
);
1426 worklist
.create (64);
1427 cfg_altered
= false;
1430 /* Cleanup after this pass. */
1433 tree_dce_done (bool aggressive
)
1438 sbitmap_free (visited_control_parents
);
1439 sbitmap_free (last_stmt_necessary
);
1440 sbitmap_free (bb_contains_live_stmts
);
1441 bb_contains_live_stmts
= NULL
;
1444 sbitmap_free (processed
);
1446 worklist
.release ();
1449 /* Main routine to eliminate dead code.
1451 AGGRESSIVE controls the aggressiveness of the algorithm.
1452 In conservative mode, we ignore control dependence and simply declare
1453 all but the most trivially dead branches necessary. This mode is fast.
1454 In aggressive mode, control dependences are taken into account, which
1455 results in more dead code elimination, but at the cost of some time.
1457 FIXME: Aggressive mode before PRE doesn't work currently because
1458 the dominance info is not invalidated after DCE1. This is
1459 not an issue right now because we only run aggressive DCE
1460 as the last tree SSA pass, but keep this in mind when you
1461 start experimenting with pass ordering. */
1464 perform_tree_ssa_dce (bool aggressive
)
1466 bool something_changed
= 0;
1468 calculate_dominance_info (CDI_DOMINATORS
);
1470 /* Preheaders are needed for SCEV to work.
1471 Simple lateches and recorded exits improve chances that loop will
1472 proved to be finite in testcases such as in loop-15.c and loop-24.c */
1474 loop_optimizer_init (LOOPS_NORMAL
1475 | LOOPS_HAVE_RECORDED_EXITS
);
1477 tree_dce_init (aggressive
);
1481 /* Compute control dependence. */
1482 calculate_dominance_info (CDI_POST_DOMINATORS
);
1483 cd
= new control_dependences (create_edge_list ());
1485 visited_control_parents
=
1486 sbitmap_alloc (last_basic_block_for_fn (cfun
));
1487 bitmap_clear (visited_control_parents
);
1489 mark_dfs_back_edges ();
1492 find_obviously_necessary_stmts (aggressive
);
1495 loop_optimizer_finalize ();
1501 visited
= BITMAP_ALLOC (NULL
);
1502 propagate_necessity (aggressive
);
1503 BITMAP_FREE (visited
);
1505 something_changed
|= eliminate_unnecessary_stmts ();
1506 something_changed
|= cfg_altered
;
1508 /* We do not update postdominators, so free them unconditionally. */
1509 free_dominance_info (CDI_POST_DOMINATORS
);
1511 /* If we removed paths in the CFG, then we need to update
1512 dominators as well. I haven't investigated the possibility
1513 of incrementally updating dominators. */
1515 free_dominance_info (CDI_DOMINATORS
);
1517 statistics_counter_event (cfun
, "Statements deleted", stats
.removed
);
1518 statistics_counter_event (cfun
, "PHI nodes deleted", stats
.removed_phis
);
1520 /* Debugging dumps. */
1521 if (dump_file
&& (dump_flags
& (TDF_STATS
|TDF_DETAILS
)))
1524 tree_dce_done (aggressive
);
1526 if (something_changed
)
1528 free_numbers_of_iterations_estimates ();
1529 if (scev_initialized_p ())
1531 return TODO_update_ssa
| TODO_cleanup_cfg
;
1536 /* Pass entry points. */
1540 return perform_tree_ssa_dce (/*aggressive=*/false);
1544 tree_ssa_cd_dce (void)
1546 return perform_tree_ssa_dce (/*aggressive=*/optimize
>= 2);
1551 const pass_data pass_data_dce
=
1553 GIMPLE_PASS
, /* type */
1555 OPTGROUP_NONE
, /* optinfo_flags */
1556 TV_TREE_DCE
, /* tv_id */
1557 ( PROP_cfg
| PROP_ssa
), /* properties_required */
1558 0, /* properties_provided */
1559 0, /* properties_destroyed */
1560 0, /* todo_flags_start */
1561 0, /* todo_flags_finish */
1564 class pass_dce
: public gimple_opt_pass
1567 pass_dce (gcc::context
*ctxt
)
1568 : gimple_opt_pass (pass_data_dce
, ctxt
)
1571 /* opt_pass methods: */
1572 opt_pass
* clone () { return new pass_dce (m_ctxt
); }
1573 virtual bool gate (function
*) { return flag_tree_dce
!= 0; }
1574 virtual unsigned int execute (function
*) { return tree_ssa_dce (); }
1576 }; // class pass_dce
1581 make_pass_dce (gcc::context
*ctxt
)
1583 return new pass_dce (ctxt
);
1588 const pass_data pass_data_cd_dce
=
1590 GIMPLE_PASS
, /* type */
1592 OPTGROUP_NONE
, /* optinfo_flags */
1593 TV_TREE_CD_DCE
, /* tv_id */
1594 ( PROP_cfg
| PROP_ssa
), /* properties_required */
1595 0, /* properties_provided */
1596 0, /* properties_destroyed */
1597 0, /* todo_flags_start */
1598 0, /* todo_flags_finish */
1601 class pass_cd_dce
: public gimple_opt_pass
1604 pass_cd_dce (gcc::context
*ctxt
)
1605 : gimple_opt_pass (pass_data_cd_dce
, ctxt
)
1608 /* opt_pass methods: */
1609 opt_pass
* clone () { return new pass_cd_dce (m_ctxt
); }
1610 virtual bool gate (function
*) { return flag_tree_dce
!= 0; }
1611 virtual unsigned int execute (function
*) { return tree_ssa_cd_dce (); }
1613 }; // class pass_cd_dce
1618 make_pass_cd_dce (gcc::context
*ctxt
)
1620 return new pass_cd_dce (ctxt
);