1 /* Dead code elimination pass for the GNU compiler.
2 Copyright (C) 2002, 2003, 2004 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 2, 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 COPYING. If not, write to the Free
21 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
24 /* Dead code elimination.
28 Building an Optimizing Compiler,
29 Robert Morgan, Butterworth-Heinemann, 1998, Section 8.9.
31 Advanced Compiler Design and Implementation,
32 Steven Muchnick, Morgan Kaufmann, 1997, Section 18.10.
34 Dead-code elimination is the removal of statements which have no
35 impact on the program's output. "Dead statements" have no impact
36 on the program's output, while "necessary statements" may have
39 The algorithm consists of three phases:
40 1. Marking as necessary all statements known to be necessary,
41 e.g. most function calls, writing a value to memory, etc;
42 2. Propagating necessary statements, e.g., the statements
43 giving values to operands in necessary statements; and
44 3. Removing dead statements. */
48 #include "coretypes.h"
53 /* These RTL headers are needed for basic-block.h. */
56 #include "hard-reg-set.h"
57 #include "basic-block.h"
60 #include "diagnostic.h"
61 #include "tree-flow.h"
62 #include "tree-gimple.h"
63 #include "tree-dump.h"
64 #include "tree-pass.h"
68 static struct stmt_stats
76 static varray_type worklist;
78 /* Vector indicating an SSA name has already been processed and marked
80 static sbitmap processed;
82 /* Vector indicating that last_stmt if a basic block has already been
83 marked as necessary. */
84 static sbitmap last_stmt_necessary;
86 /* Before we can determine whether a control branch is dead, we need to
87 compute which blocks are control dependent on which edges.
89 We expect each block to be control dependent on very few edges so we
90 use a bitmap for each block recording its edges. An array holds the
91 bitmap. The Ith bit in the bitmap is set if that block is dependent
93 bitmap *control_dependence_map;
95 /* Execute CODE for each edge (given number EDGE_NUMBER within the CODE)
96 for which the block with index N is control dependent. */
97 #define EXECUTE_IF_CONTROL_DEPENDENT(N, EDGE_NUMBER, CODE) \
98 EXECUTE_IF_SET_IN_BITMAP (control_dependence_map[N], 0, EDGE_NUMBER, CODE)
100 /* Local function prototypes. */
101 static inline void set_control_dependence_map_bit (basic_block, int);
102 static inline void clear_control_dependence_bitmap (basic_block);
103 static void find_all_control_dependences (struct edge_list *);
104 static void find_control_dependence (struct edge_list *, int);
105 static inline basic_block find_pdom (basic_block);
107 static inline void mark_stmt_necessary (tree, bool);
108 static inline void mark_operand_necessary (tree);
110 static void mark_stmt_if_obviously_necessary (tree, bool);
111 static void find_obviously_necessary_stmts (struct edge_list *);
113 static void mark_control_dependent_edges_necessary (basic_block, struct edge_list *);
114 static void propagate_necessity (struct edge_list *);
116 static void eliminate_unnecessary_stmts (void);
117 static void remove_dead_phis (basic_block);
118 static void remove_dead_stmt (block_stmt_iterator *, basic_block);
120 static void print_stats (void);
121 static void tree_dce_init (bool);
122 static void tree_dce_done (bool);
124 /* Indicate block BB is control dependent on an edge with index EDGE_INDEX. */
126 set_control_dependence_map_bit (basic_block bb, int edge_index)
128 if (bb == ENTRY_BLOCK_PTR)
130 if (bb == EXIT_BLOCK_PTR)
132 bitmap_set_bit (control_dependence_map[bb->index], edge_index);
135 /* Clear all control dependences for block BB. */
137 void clear_control_dependence_bitmap (basic_block bb)
139 bitmap_clear (control_dependence_map[bb->index]);
142 /* Record all blocks' control dependences on all edges in the edge
143 list EL, ala Morgan, Section 3.6. */
146 find_all_control_dependences (struct edge_list *el)
150 for (i = 0; i < NUM_EDGES (el); ++i)
151 find_control_dependence (el, i);
154 /* Determine all blocks' control dependences on the given edge with edge_list
155 EL index EDGE_INDEX, ala Morgan, Section 3.6. */
158 find_control_dependence (struct edge_list *el, int edge_index)
160 basic_block current_block;
161 basic_block ending_block;
163 #ifdef ENABLE_CHECKING
164 if (INDEX_EDGE_PRED_BB (el, edge_index) == EXIT_BLOCK_PTR)
168 if (INDEX_EDGE_PRED_BB (el, edge_index) == ENTRY_BLOCK_PTR)
169 ending_block = ENTRY_BLOCK_PTR->next_bb;
171 ending_block = find_pdom (INDEX_EDGE_PRED_BB (el, edge_index));
173 for (current_block = INDEX_EDGE_SUCC_BB (el, edge_index);
174 current_block != ending_block && current_block != EXIT_BLOCK_PTR;
175 current_block = find_pdom (current_block))
177 edge e = INDEX_EDGE (el, edge_index);
179 /* For abnormal edges, we don't make current_block control
180 dependent because instructions that throw are always necessary
182 if (e->flags & EDGE_ABNORMAL)
185 set_control_dependence_map_bit (current_block, edge_index);
189 /* Find the immediate postdominator PDOM of the specified basic block BLOCK.
190 This function is necessary because some blocks have negative numbers. */
192 static inline basic_block
193 find_pdom (basic_block block)
195 if (block == ENTRY_BLOCK_PTR)
197 else if (block == EXIT_BLOCK_PTR)
198 return EXIT_BLOCK_PTR;
201 basic_block bb = get_immediate_dominator (CDI_POST_DOMINATORS, block);
203 return EXIT_BLOCK_PTR;
208 #define NECESSARY(stmt) stmt->common.asm_written_flag
210 /* If STMT is not already marked necessary, mark it, and add it to the
211 worklist if ADD_TO_WORKLIST is true. */
213 mark_stmt_necessary (tree stmt, bool add_to_worklist)
215 #ifdef ENABLE_CHECKING
217 || stmt == error_mark_node
218 || (stmt && DECL_P (stmt)))
222 if (NECESSARY (stmt))
225 if (dump_file && (dump_flags & TDF_DETAILS))
227 fprintf (dump_file, "Marking useful stmt: ");
228 print_generic_stmt (dump_file, stmt, TDF_SLIM);
229 fprintf (dump_file, "\n");
232 NECESSARY (stmt) = 1;
234 VARRAY_PUSH_TREE (worklist, stmt);
237 /* Mark the statement defining operand OP as necessary. */
240 mark_operand_necessary (tree op)
245 #ifdef ENABLE_CHECKING
250 ver = SSA_NAME_VERSION (op);
251 if (TEST_BIT (processed, ver))
253 SET_BIT (processed, ver);
255 stmt = SSA_NAME_DEF_STMT (op);
256 #ifdef ENABLE_CHECKING
262 || IS_EMPTY_STMT (stmt))
265 NECESSARY (stmt) = 1;
266 VARRAY_PUSH_TREE (worklist, stmt);
270 /* Mark STMT as necessary if it is obviously is. Add it to the worklist if
271 it can make other statements necessary.
273 If AGGRESSIVE is false, control statements are conservatively marked as
277 mark_stmt_if_obviously_necessary (tree stmt, bool aggressive)
279 v_may_def_optype v_may_defs;
280 v_must_def_optype v_must_defs;
285 /* Statements that are implicitly live. Most function calls, asm and return
286 statements are required. Labels and BIND_EXPR nodes are kept because
287 they are control flow, and we have no way of knowing whether they can be
288 removed. DCE can eliminate all the other statements in a block, and CFG
289 can then remove the block and labels. */
290 switch (TREE_CODE (stmt))
294 case CASE_LABEL_EXPR:
295 mark_stmt_necessary (stmt, false);
301 mark_stmt_necessary (stmt, true);
305 /* Most, but not all function calls are required. Function calls that
306 produce no result and have no side effects (i.e. const pure
307 functions) are unnecessary. */
308 if (TREE_SIDE_EFFECTS (stmt))
309 mark_stmt_necessary (stmt, true);
313 op = get_call_expr_in (stmt);
314 if (op && TREE_SIDE_EFFECTS (op))
316 mark_stmt_necessary (stmt, true);
320 /* These values are mildly magic bits of the EH runtime. We can't
321 see the entire lifetime of these values until landing pads are
323 if (TREE_CODE (TREE_OPERAND (stmt, 0)) == EXC_PTR_EXPR
324 || TREE_CODE (TREE_OPERAND (stmt, 0)) == FILTER_EXPR)
326 mark_stmt_necessary (stmt, true);
332 if (! simple_goto_p (stmt))
333 mark_stmt_necessary (stmt, true);
337 if (GOTO_DESTINATION (COND_EXPR_THEN (stmt))
338 == GOTO_DESTINATION (COND_EXPR_ELSE (stmt)))
340 /* A COND_EXPR is obviously dead if the target labels are the same.
341 We cannot kill the statement at this point, so to prevent the
342 statement from being marked necessary, we replace the condition
343 with a constant. The stmt is killed later on in cfg_cleanup. */
344 COND_EXPR_COND (stmt) = integer_zero_node;
352 mark_stmt_necessary (stmt, true);
359 ann = stmt_ann (stmt);
361 /* If the statement has volatile operands, it needs to be preserved.
362 Same for statements that can alter control flow in unpredictable
364 if (ann->has_volatile_ops || is_ctrl_altering_stmt (stmt))
366 mark_stmt_necessary (stmt, true);
370 get_stmt_operands (stmt);
372 FOR_EACH_SSA_TREE_OPERAND (def, stmt, iter, SSA_OP_DEF)
374 if (is_global_var (SSA_NAME_VAR (def)))
376 mark_stmt_necessary (stmt, true);
381 /* Check virtual definitions. If we get here, the only virtual
382 definitions we should see are those generated by assignment
384 v_may_defs = V_MAY_DEF_OPS (ann);
385 v_must_defs = V_MUST_DEF_OPS (ann);
386 if (NUM_V_MAY_DEFS (v_may_defs) > 0 || NUM_V_MUST_DEFS (v_must_defs) > 0)
390 #if defined ENABLE_CHECKING
391 if (TREE_CODE (stmt) != MODIFY_EXPR)
395 /* Note that we must not check the individual virtual operands
396 here. In particular, if this is an aliased store, we could
397 end up with something like the following (SSA notation
398 redacted for brevity):
403 p_1 = (i_2 > 3) ? &x : p_1;
405 # x_4 = V_MAY_DEF <x_3>
411 Notice that the store to '*p_1' should be preserved, if we
412 were to check the virtual definitions in that store, we would
413 not mark it needed. This is because 'x' is not a global
416 Therefore, we check the base address of the LHS. If the
417 address is a pointer, we check if its name tag or type tag is
418 a global variable. Otherwise, we check if the base variable
420 lhs = TREE_OPERAND (stmt, 0);
421 if (TREE_CODE_CLASS (TREE_CODE (lhs)) == 'r')
422 lhs = get_base_address (lhs);
424 if (lhs == NULL_TREE)
426 /* If LHS is NULL, it means that we couldn't get the base
427 address of the reference. In which case, we should not
428 remove this store. */
429 mark_stmt_necessary (stmt, true);
431 else if (DECL_P (lhs))
433 /* If the store is to a global symbol, we need to keep it. */
434 if (is_global_var (lhs))
435 mark_stmt_necessary (stmt, true);
437 else if (TREE_CODE (lhs) == INDIRECT_REF)
439 tree ptr = TREE_OPERAND (lhs, 0);
440 struct ptr_info_def *pi = SSA_NAME_PTR_INFO (ptr);
441 tree nmt = (pi) ? pi->name_mem_tag : NULL_TREE;
442 tree tmt = var_ann (SSA_NAME_VAR (ptr))->type_mem_tag;
444 /* If either the name tag or the type tag for PTR is a
445 global variable, then the store is necessary. */
446 if ((nmt && is_global_var (nmt))
447 || (tmt && is_global_var (tmt)))
449 mark_stmt_necessary (stmt, true);
460 /* Find obviously necessary statements. These are things like most function
461 calls, and stores to file level variables.
463 If EL is NULL, control statements are conservatively marked as
464 necessary. Otherwise it contains the list of edges used by control
465 dependence analysis. */
468 find_obviously_necessary_stmts (struct edge_list *el)
471 block_stmt_iterator i;
478 /* Check any PHI nodes in the block. */
479 for (phi = phi_nodes (bb); phi; phi = PHI_CHAIN (phi))
483 /* PHIs for virtual variables do not directly affect code
484 generation and need not be considered inherently necessary
485 regardless of the bits set in their decl.
487 Thus, we only need to mark PHIs for real variables which
488 need their result preserved as being inherently necessary. */
489 if (is_gimple_reg (PHI_RESULT (phi))
490 && is_global_var (SSA_NAME_VAR (PHI_RESULT (phi))))
491 mark_stmt_necessary (phi, true);
494 /* Check all statements in the block. */
495 for (i = bsi_start (bb); ! bsi_end_p (i); bsi_next (&i))
497 tree stmt = bsi_stmt (i);
498 NECESSARY (stmt) = 0;
499 mark_stmt_if_obviously_necessary (stmt, el != NULL);
502 /* Mark this basic block as `not visited'. A block will be marked
503 visited when the edges that it is control dependent on have been
505 bb->flags &= ~BB_VISITED;
510 /* Prevent the loops from being removed. We must keep the infinite loops,
511 and we currently do not have a means to recognize the finite ones. */
514 for (e = bb->succ; e; e = e->succ_next)
515 if (e->flags & EDGE_DFS_BACK)
516 mark_control_dependent_edges_necessary (e->dest, el);
521 /* Make corresponding control dependent edges necessary. We only
522 have to do this once for each basic block, so we clear the bitmap
525 mark_control_dependent_edges_necessary (basic_block bb, struct edge_list *el)
529 #ifdef ENABLE_CHECKING
530 if (bb == EXIT_BLOCK_PTR)
534 if (bb == ENTRY_BLOCK_PTR)
537 EXECUTE_IF_CONTROL_DEPENDENT (bb->index, edge_number,
540 basic_block cd_bb = INDEX_EDGE_PRED_BB (el, edge_number);
542 if (TEST_BIT (last_stmt_necessary, cd_bb->index))
544 SET_BIT (last_stmt_necessary, cd_bb->index);
546 t = last_stmt (cd_bb);
547 if (t && is_ctrl_stmt (t))
548 mark_stmt_necessary (t, true);
552 /* Propagate necessity using the operands of necessary statements. Process
553 the uses on each statement in the worklist, and add all feeding statements
554 which contribute to the calculation of this value to the worklist.
556 In conservative mode, EL is NULL. */
559 propagate_necessity (struct edge_list *el)
562 bool aggressive = (el ? true : false);
564 if (dump_file && (dump_flags & TDF_DETAILS))
565 fprintf (dump_file, "\nProcessing worklist:\n");
567 while (VARRAY_ACTIVE_SIZE (worklist) > 0)
569 /* Take `i' from worklist. */
570 i = VARRAY_TOP_TREE (worklist);
571 VARRAY_POP (worklist);
573 if (dump_file && (dump_flags & TDF_DETAILS))
575 fprintf (dump_file, "processing: ");
576 print_generic_stmt (dump_file, i, TDF_SLIM);
577 fprintf (dump_file, "\n");
582 /* Mark the last statements of the basic blocks that the block
583 containing `i' is control dependent on, but only if we haven't
585 basic_block bb = bb_for_stmt (i);
586 if (! (bb->flags & BB_VISITED))
588 bb->flags |= BB_VISITED;
589 mark_control_dependent_edges_necessary (bb, el);
593 if (TREE_CODE (i) == PHI_NODE)
595 /* PHI nodes are somewhat special in that each PHI alternative has
596 data and control dependencies. All the statements feeding the
597 PHI node's arguments are always necessary. In aggressive mode,
598 we also consider the control dependent edges leading to the
599 predecessor block associated with each PHI alternative as
602 for (k = 0; k < PHI_NUM_ARGS (i); k++)
604 tree arg = PHI_ARG_DEF (i, k);
605 if (TREE_CODE (arg) == SSA_NAME)
606 mark_operand_necessary (arg);
611 for (k = 0; k < PHI_NUM_ARGS (i); k++)
613 basic_block arg_bb = PHI_ARG_EDGE (i, k)->src;
614 if (! (arg_bb->flags & BB_VISITED))
616 arg_bb->flags |= BB_VISITED;
617 mark_control_dependent_edges_necessary (arg_bb, el);
624 /* Propagate through the operands. Examine all the USE, VUSE and
625 V_MAY_DEF operands in this statement. Mark all the statements
626 which feed this statement's uses as necessary. */
630 get_stmt_operands (i);
632 /* The operands of V_MAY_DEF expressions are also needed as they
633 represent potential definitions that may reach this
634 statement (V_MAY_DEF operands allow us to follow def-def
637 FOR_EACH_SSA_TREE_OPERAND (use, i, iter, SSA_OP_ALL_USES)
638 mark_operand_necessary (use);
643 /* Eliminate unnecessary statements. Any instruction not marked as necessary
644 contributes nothing to the program, and can be deleted. */
647 eliminate_unnecessary_stmts (void)
650 block_stmt_iterator i;
652 if (dump_file && (dump_flags & TDF_DETAILS))
653 fprintf (dump_file, "\nEliminating unnecessary statements:\n");
655 clear_special_calls ();
658 /* Remove dead PHI nodes. */
659 remove_dead_phis (bb);
661 /* Remove dead statements. */
662 for (i = bsi_start (bb); ! bsi_end_p (i) ; )
664 tree t = bsi_stmt (i);
668 /* If `i' is not necessary then remove it. */
670 remove_dead_stmt (&i, bb);
673 tree call = get_call_expr_in (t);
675 notice_special_calls (call);
682 /* Remove dead PHI nodes from block BB. */
685 remove_dead_phis (basic_block bb)
690 phi = phi_nodes (bb);
695 if (! NECESSARY (phi))
697 tree next = PHI_CHAIN (phi);
699 if (dump_file && (dump_flags & TDF_DETAILS))
701 fprintf (dump_file, "Deleting : ");
702 print_generic_stmt (dump_file, phi, TDF_SLIM);
703 fprintf (dump_file, "\n");
706 remove_phi_node (phi, prev, bb);
707 stats.removed_phis++;
713 phi = PHI_CHAIN (phi);
718 /* Remove dead statement pointed by iterator I. Receives the basic block BB
719 containing I so that we don't have to look it up. */
722 remove_dead_stmt (block_stmt_iterator *i, basic_block bb)
724 tree t = bsi_stmt (*i);
726 if (dump_file && (dump_flags & TDF_DETAILS))
728 fprintf (dump_file, "Deleting : ");
729 print_generic_stmt (dump_file, t, TDF_SLIM);
730 fprintf (dump_file, "\n");
735 /* If we have determined that a conditional branch statement contributes
736 nothing to the program, then we not only remove it, but we also change
737 the flow graph so that the current block will simply fall-thru to its
738 immediate post-dominator. The blocks we are circumventing will be
739 removed by cleaup_cfg if this change in the flow graph makes them
741 if (is_ctrl_stmt (t))
743 basic_block post_dom_bb;
745 #ifdef ENABLE_CHECKING
746 /* The post dominance info has to be up-to-date. */
747 if (dom_computed[CDI_POST_DOMINATORS] != DOM_OK)
750 /* Get the immediate post dominator of bb. */
751 post_dom_bb = get_immediate_dominator (CDI_POST_DOMINATORS, bb);
752 /* Some blocks don't have an immediate post dominator. This can happen
753 for example with infinite loops. Removing an infinite loop is an
754 inappropriate transformation anyway... */
761 /* Redirect the first edge out of BB to reach POST_DOM_BB. */
762 redirect_edge_and_branch (bb->succ, post_dom_bb);
763 PENDING_STMT (bb->succ) = NULL;
765 /* The edge is no longer associated with a conditional, so it does
766 not have TRUE/FALSE flags. */
767 bb->succ->flags &= ~(EDGE_TRUE_VALUE | EDGE_FALSE_VALUE);
769 /* If the edge reaches any block other than the exit, then it is a
770 fallthru edge; if it reaches the exit, then it is not a fallthru
772 if (post_dom_bb != EXIT_BLOCK_PTR)
773 bb->succ->flags |= EDGE_FALLTHRU;
775 bb->succ->flags &= ~EDGE_FALLTHRU;
777 /* Remove the remaining the outgoing edges. */
778 for (e = bb->succ->succ_next; e != NULL;)
790 /* Print out removed statement statistics. */
795 if (dump_file && (dump_flags & (TDF_STATS|TDF_DETAILS)))
799 percg = ((float) stats.removed / (float) stats.total) * 100;
800 fprintf (dump_file, "Removed %d of %d statements (%d%%)\n",
801 stats.removed, stats.total, (int) percg);
803 if (stats.total_phis == 0)
806 percg = ((float) stats.removed_phis / (float) stats.total_phis) * 100;
808 fprintf (dump_file, "Removed %d of %d PHI nodes (%d%%)\n",
809 stats.removed_phis, stats.total_phis, (int) percg);
813 /* Initialization for this pass. Set up the used data structures. */
816 tree_dce_init (bool aggressive)
818 memset ((void *) &stats, 0, sizeof (stats));
824 control_dependence_map
825 = xmalloc (last_basic_block * sizeof (bitmap));
826 for (i = 0; i < last_basic_block; ++i)
827 control_dependence_map[i] = BITMAP_XMALLOC ();
829 last_stmt_necessary = sbitmap_alloc (last_basic_block);
830 sbitmap_zero (last_stmt_necessary);
833 processed = sbitmap_alloc (num_ssa_names + 1);
834 sbitmap_zero (processed);
836 VARRAY_TREE_INIT (worklist, 64, "work list");
839 /* Cleanup after this pass. */
842 tree_dce_done (bool aggressive)
848 for (i = 0; i < last_basic_block; ++i)
849 BITMAP_XFREE (control_dependence_map[i]);
850 free (control_dependence_map);
852 sbitmap_free (last_stmt_necessary);
855 sbitmap_free (processed);
858 /* Main routine to eliminate dead code.
860 AGGRESSIVE controls the aggressiveness of the algorithm.
861 In conservative mode, we ignore control dependence and simply declare
862 all but the most trivially dead branches necessary. This mode is fast.
863 In aggressive mode, control dependences are taken into account, which
864 results in more dead code elimination, but at the cost of some time.
866 FIXME: Aggressive mode before PRE doesn't work currently because
867 the dominance info is not invalidated after DCE1. This is
868 not an issue right now because we only run aggressive DCE
869 as the last tree SSA pass, but keep this in mind when you
870 start experimenting with pass ordering. */
873 perform_tree_ssa_dce (bool aggressive)
875 struct edge_list *el = NULL;
877 tree_dce_init (aggressive);
881 /* Compute control dependence. */
882 timevar_push (TV_CONTROL_DEPENDENCES);
883 calculate_dominance_info (CDI_POST_DOMINATORS);
884 el = create_edge_list ();
885 find_all_control_dependences (el);
886 timevar_pop (TV_CONTROL_DEPENDENCES);
888 mark_dfs_back_edges ();
891 find_obviously_necessary_stmts (el);
893 propagate_necessity (el);
895 eliminate_unnecessary_stmts ();
898 free_dominance_info (CDI_POST_DOMINATORS);
902 /* Debugging dumps. */
905 dump_function_to_file (current_function_decl, dump_file, dump_flags);
909 tree_dce_done (aggressive);
914 /* Pass entry points. */
918 perform_tree_ssa_dce (/*aggressive=*/false);
922 tree_ssa_cd_dce (void)
924 perform_tree_ssa_dce (/*aggressive=*/optimize >= 2);
930 return flag_tree_dce != 0;
933 struct tree_opt_pass pass_dce =
937 tree_ssa_dce, /* execute */
940 0, /* static_pass_number */
941 TV_TREE_DCE, /* tv_id */
942 PROP_cfg | PROP_ssa | PROP_alias, /* properties_required */
943 0, /* properties_provided */
944 0, /* properties_destroyed */
945 0, /* todo_flags_start */
946 TODO_ggc_collect | TODO_verify_ssa /* todo_flags_finish */
949 struct tree_opt_pass pass_cd_dce =
953 tree_ssa_cd_dce, /* execute */
956 0, /* static_pass_number */
957 TV_TREE_CD_DCE, /* tv_id */
958 PROP_cfg | PROP_ssa | PROP_alias, /* properties_required */
959 0, /* properties_provided */
960 0, /* properties_destroyed */
961 0, /* todo_flags_start */
962 TODO_ggc_collect | TODO_verify_ssa | TODO_verify_flow
963 /* todo_flags_finish */