GCC Middle and Back End API Reference
tree-ssa-dce.cc File Reference
#include "config.h"
#include "system.h"
#include "coretypes.h"
#include "backend.h"
#include "rtl.h"
#include "tree.h"
#include "gimple.h"
#include "cfghooks.h"
#include "tree-pass.h"
#include "ssa.h"
#include "gimple-pretty-print.h"
#include "fold-const.h"
#include "calls.h"
#include "cfganal.h"
#include "tree-eh.h"
#include "gimplify.h"
#include "gimple-iterator.h"
#include "tree-cfg.h"
#include "tree-ssa-loop-niter.h"
#include "tree-into-ssa.h"
#include "tree-dfa.h"
#include "cfgloop.h"
#include "tree-scalar-evolution.h"
#include "tree-ssa-propagate.h"
#include "gimple-fold.h"
#include "tree-ssa.h"
Include dependency graph for tree-ssa-dce.cc:

Data Structures

struct  stmt_stats
 

Macros

#define STMT_NECESSARY   GF_PLF_1
 

Functions

static bool keep_all_vdefs_p ()
 
static void mark_stmt_necessary (gimple *stmt, bool add_to_worklist)
 
static void mark_operand_necessary (tree op)
 
static void mark_stmt_if_obviously_necessary (gimple *stmt, bool aggressive)
 
static bool mark_last_stmt_necessary (basic_block bb)
 
static void mark_control_dependent_edges_necessary (basic_block bb, bool ignore_self)
 
static void find_obviously_necessary_stmts (bool aggressive)
 
static bool ref_may_be_aliased (tree ref)
 
static bool mark_aliased_reaching_defs_necessary_1 (ao_ref *ref, tree vdef, void *data)
 
static void mark_aliased_reaching_defs_necessary (gimple *stmt, tree ref)
 
static bool mark_all_reaching_defs_necessary_1 (ao_ref *ref, tree vdef, void *data)
 
static void mark_all_reaching_defs_necessary (gimple *stmt)
 
static bool degenerate_phi_p (gimple *phi)
 
static bool valid_new_delete_pair_p (gimple *new_call, gimple *delete_call)
 
static void propagate_necessity (bool aggressive)
 
static bool remove_dead_phis (basic_block bb)
 
static void remove_dead_stmt (gimple_stmt_iterator *i, basic_block bb, vec< edge > &to_remove_edges)
 
static tree find_non_realpart_uses (tree *tp, int *walk_subtrees, void *data)
 
static void maybe_optimize_arith_overflow (gimple_stmt_iterator *gsi, enum tree_code subcode)
 
static bool control_parents_preserved_p (basic_block bb)
 
static bool eliminate_unnecessary_stmts (bool aggressive)
 
static void print_stats (void)
 
static void tree_dce_init (bool aggressive)
 
static void tree_dce_done (bool aggressive)
 
static int sort_phi_args (const void *a_, const void *b_)
 
static unsigned make_forwarders_with_degenerate_phis (function *fn)
 
static unsigned int perform_tree_ssa_dce (bool aggressive)
 
static unsigned int tree_ssa_dce (void)
 
static unsigned int tree_ssa_cd_dce (void)
 
gimple_opt_passmake_pass_dce (gcc::context *ctxt)
 
gimple_opt_passmake_pass_cd_dce (gcc::context *ctxt)
 
void simple_dce_from_worklist (bitmap worklist, bitmap need_eh_cleanup)
 

Variables

static struct stmt_stats stats
 
static vec< gimple * > worklist
 
static sbitmap processed
 
static sbitmap last_stmt_necessary
 
static sbitmap bb_contains_live_stmts
 
static control_dependencescd
 
static sbitmap visited_control_parents
 
static bool cfg_altered
 
static int * bb_postorder
 
static bitmap visited = NULL
 
static unsigned int longest_chain = 0
 
static unsigned int total_chain = 0
 
static unsigned int nr_walks = 0
 
static bool chain_ovfl = false
 

Macro Definition Documentation

◆ STMT_NECESSARY

Function Documentation

◆ control_parents_preserved_p()

◆ degenerate_phi_p()

static bool degenerate_phi_p ( gimple * phi)
static
Return true for PHI nodes with one or identical arguments
can be removed.   

References gimple_phi_arg_def(), gimple_phi_num_args(), and i.

Referenced by propagate_necessity(), and remove_dead_phis().

◆ eliminate_unnecessary_stmts()

static bool eliminate_unnecessary_stmts ( bool aggressive)
static
Eliminate unnecessary statements. Any instruction not marked as necessary
contributes nothing to the program, and can be deleted.   

References ALLOCA_FUNCTION_CODE_P, bb_contains_live_stmts, bb_postorder, bitmap_bit_p, bitmap_clear(), bitmap_set_bit, BUILT_IN_NORMAL, CDI_DOMINATORS, cfg_altered, cfun, clear_special_calls(), control_parents_preserved_p(), DECL_BUILT_IN_CLASS, DECL_FUNCTION_CODE(), DECL_IS_REPLACEABLE_OPERATOR_NEW_P, DECL_UID, delete_basic_block(), dom_info_available_p(), dump_file, dump_flags, ei_next(), ei_safe_edge(), ei_start, ENTRY_BLOCK_PTR_FOR_FN, EXIT_BLOCK_PTR_FOR_FN, find_unreachable_blocks(), first_dom_son(), basic_block_def::flags, FOR_EACH_BB_FN, FOR_EACH_IMM_USE_STMT, FOR_EACH_SSA_USE_OPERAND, free(), gcc_assert, get_all_dominated_blocks(), ggc_alloc(), gimple_bb(), gimple_call_arg(), gimple_call_builtin_p(), gimple_call_fndecl(), gimple_call_from_new_or_delete(), gimple_call_internal_fn(), gimple_call_internal_p(), gimple_call_lhs(), gimple_call_num_args(), gimple_call_operator_delete_p(), gimple_call_set_lhs(), gimple_clobber_p(), gimple_debug_bind_get_var(), gimple_debug_bind_p(), gimple_nop_p(), gimple_phi_result(), gimple_plf(), gimple_set_plf(), gsi_end_p(), gsi_last_bb(), gsi_next(), gsi_prev(), gsi_start_phis(), gsi_stmt(), i, basic_block_def::index, integer_nonzerop(), integer_zerop(), is_gimple_call(), is_gimple_debug(), mark_virtual_phi_result_for_renaming(), maybe_clean_or_replace_eh_stmt(), maybe_optimize_arith_overflow(), notice_special_calls(), NULL, NULL_TREE, basic_block_def::prev_bb, print_gimple_stmt(), processed, release_ssa_name(), remove_dead_phis(), remove_dead_stmt(), remove_edge(), single_succ(), SSA_NAME_DEF_STMT, SSA_NAME_IS_DEFAULT_DEF, SSA_NAME_VERSION, SSA_OP_USE, stmt_can_make_abnormal_goto(), STMT_NECESSARY, basic_block_def::succs, TDF_DETAILS, TDF_SLIM, TREE_CODE, update_stmt(), USE_FROM_PTR, and virtual_operand_p().

Referenced by perform_tree_ssa_dce().

◆ find_non_realpart_uses()

static tree find_non_realpart_uses ( tree * tp,
int * walk_subtrees,
void * data )
static
Helper for maybe_optimize_arith_overflow.  Find in *TP if there are any
uses of data (SSA_NAME) other than REALPART_EXPR referencing it.   

References ggc_alloc(), NULL_TREE, TREE_CODE, and TYPE_P.

Referenced by maybe_optimize_arith_overflow().

◆ find_obviously_necessary_stmts()

static void find_obviously_necessary_stmts ( bool aggressive)
static
Find obviously necessary statements.  These are things like most function
calls, and stores to file level variables.

If EL is NULL, control statements are conservatively marked as
necessary.  Otherwise it contains the list of edges used by control
dependence analysis.   

References cfun, current_function_decl, dump_file, loop_exit::e, ECF_CONST, ECF_LOOPING_CONST_OR_PURE, ECF_PURE, loop::exits, finite_loop_p(), flags_from_decl_or_type(), FOR_EACH_BB_FN, FOR_EACH_EDGE, ggc_alloc(), gimple_set_plf(), gsi_end_p(), gsi_next(), gsi_start_bb(), gsi_start_phis(), gsi_stmt(), loop::latch, mark_control_dependent_edges_necessary(), mark_irreducible_loops(), mark_stmt_if_obviously_necessary(), loop_exit::next, loop::num, STMT_NECESSARY, and basic_block_def::succs.

Referenced by perform_tree_ssa_dce().

◆ keep_all_vdefs_p()

static bool keep_all_vdefs_p ( )
inlinestatic
True if we should treat any stmt with a vdef as necessary.   

References ggc_alloc().

Referenced by mark_aliased_reaching_defs_necessary(), mark_all_reaching_defs_necessary(), mark_stmt_if_obviously_necessary(), and propagate_necessity().

◆ make_forwarders_with_degenerate_phis()

◆ make_pass_cd_dce()

gimple_opt_pass * make_pass_cd_dce ( gcc::context * ctxt)

References ggc_alloc().

◆ make_pass_dce()

gimple_opt_pass * make_pass_dce ( gcc::context * ctxt)

References ggc_alloc().

◆ mark_aliased_reaching_defs_necessary()

◆ mark_aliased_reaching_defs_necessary_1()

static bool mark_aliased_reaching_defs_necessary_1 ( ao_ref * ref,
tree vdef,
void * data )
static
Worker for the walker that marks reaching definitions of REF,
which is based on a non-aliased decl, necessary.  It returns
true whenever the defining statement of the current VDEF is
a kill for REF, as no dominating may-defs are necessary for REF
anymore.  DATA points to the basic-block that contains the
stmt that refers to REF.   

References ao_ref_base(), ao_ref::base, CDI_DOMINATORS, cfun, dominated_by_p(), get_ref_base_and_extent(), ggc_alloc(), gimple_bb(), gimple_clobber_p(), gimple_get_lhs(), gimple_has_lhs(), known_eq, mark_operand_necessary(), ao_ref::max_size, offset, ao_ref::offset, operand_equal_p(), ao_ref::ref, SSA_NAME_DEF_STMT, stmt_can_throw_internal(), and TREE_CODE.

Referenced by mark_aliased_reaching_defs_necessary().

◆ mark_all_reaching_defs_necessary()

◆ mark_all_reaching_defs_necessary_1()

static bool mark_all_reaching_defs_necessary_1 ( ao_ref * ref,
tree vdef,
void * data )
static
Worker for the walker that marks reaching definitions of REF, which
is not based on a non-aliased decl.  For simplicity we need to end
up marking all may-defs necessary that are not based on a non-aliased
decl.  The only job of this walker is to skip may-defs based on
a non-aliased decl.   

References bitmap_bit_p, BUILT_IN_NORMAL, CASE_BUILT_IN_ALLOCA, chain_ovfl, DECL_FUNCTION_CODE(), DECL_IS_OPERATOR_DELETE_P, DECL_IS_REPLACEABLE_OPERATOR_NEW_P, fndecl_built_in_p(), gcc_assert, ggc_alloc(), gimple_assign_lhs(), gimple_assign_single_p(), gimple_call_fndecl(), gimple_call_from_new_or_delete(), gimple_clobber_p(), gimple_nop_p(), gimple_plf(), mark_operand_necessary(), NULL_TREE, processed, ref_may_be_aliased(), SSA_NAME_DEF_STMT, SSA_NAME_VERSION, and STMT_NECESSARY.

Referenced by mark_all_reaching_defs_necessary().

◆ mark_control_dependent_edges_necessary()

static void mark_control_dependent_edges_necessary ( basic_block bb,
bool ignore_self )
static
Mark control dependent edges of BB as necessary.  We have to do this only
once for each basic block so we set the appropriate bit after we're done.

When IGNORE_SELF is true, ignore BB in the list of control dependences.   

References bitmap_set_bit, cd, cfun, ENTRY_BLOCK_PTR_FOR_FN, EXECUTE_IF_SET_IN_BITMAP, EXIT_BLOCK_PTR_FOR_FN, gcc_assert, control_dependences::get_edge_src(), control_dependences::get_edges_dependent_on(), ggc_alloc(), basic_block_def::index, mark_control_dependent_edges_necessary(), mark_last_stmt_necessary(), and visited_control_parents.

Referenced by find_obviously_necessary_stmts(), mark_control_dependent_edges_necessary(), and propagate_necessity().

◆ mark_last_stmt_necessary()

◆ mark_operand_necessary()

◆ mark_stmt_if_obviously_necessary()

◆ mark_stmt_necessary()

static void mark_stmt_necessary ( gimple * stmt,
bool add_to_worklist )
inlinestatic

◆ maybe_optimize_arith_overflow()

◆ perform_tree_ssa_dce()

static unsigned int perform_tree_ssa_dce ( bool aggressive)
static
Main routine to eliminate dead code.

AGGRESSIVE controls the aggressiveness of the algorithm.
In conservative mode, we ignore control dependence and simply declare
all but the most trivially dead branches necessary.  This mode is fast.
In aggressive mode, control dependences are taken into account, which
results in more dead code elimination, but at the cost of some time.

FIXME: Aggressive mode before PRE doesn't work currently because
       the dominance info is not invalidated after DCE1.  This is
       not an issue right now because we only run aggressive DCE
       as the last tree SSA pass, but keep this in mind when you
       start experimenting with pass ordering.   

References BITMAP_ALLOC, bitmap_clear(), BITMAP_FREE, calculate_dominance_info(), cd, CDI_DOMINATORS, CDI_POST_DOMINATORS, cfg_altered, cfun, chain_ovfl, dump_file, dump_flags, eliminate_unnecessary_stmts(), find_obviously_necessary_stmts(), free_dominance_info(), free_numbers_of_iterations_estimates(), ggc_alloc(), last_basic_block_for_fn, longest_chain, loop_optimizer_finalize(), loop_optimizer_init(), LOOPS_HAVE_RECORDED_EXITS, LOOPS_NORMAL, make_forwarders_with_degenerate_phis(), mark_dfs_back_edges(), nr_walks, NULL, print_stats(), propagate_necessity(), sbitmap_alloc(), scev_finalize(), scev_initialize(), scev_initialized_p(), scev_reset(), statistics_counter_event(), TDF_DETAILS, TDF_STATS, todo, TODO_cleanup_cfg, TODO_update_ssa, total_chain, tree_dce_done(), tree_dce_init(), visited, and visited_control_parents.

Referenced by tree_ssa_cd_dce(), and tree_ssa_dce().

◆ print_stats()

static void print_stats ( void )
static
Print out removed statement statistics.   

References dump_file, and ggc_alloc().

Referenced by perform_tree_ssa_dce().

◆ propagate_necessity()

static void propagate_necessity ( bool aggressive)
static
Propagate necessity using the operands of necessary statements.
Process the uses on each statement in the worklist, and add all
feeding statements which contribute to the calculation of this
value to the worklist.

In conservative mode, EL is NULL.   

References ALLOCA_FUNCTION_CODE_P, bitmap_bit_p, bitmap_clear(), BUILT_IN_NORMAL, CDI_POST_DOMINATORS, cfun, chain_ovfl, DECL_BUILT_IN_CLASS, DECL_FUNCTION_CODE(), DECL_IS_OPERATOR_DELETE_P, DECL_IS_REPLACEABLE_OPERATOR_NEW_P, degenerate_phi_p(), dump_file, dump_flags, ENTRY_BLOCK_PTR_FOR_FN, FOR_EACH_SSA_TREE_OPERAND, gcc_unreachable, get_immediate_dominator(), ggc_alloc(), gimple_asm_input_op(), gimple_asm_ninputs(), gimple_assign_rhs1(), gimple_assign_single_p(), gimple_bb(), gimple_call_arg(), gimple_call_builtin_p(), gimple_call_fndecl(), gimple_call_from_new_or_delete(), gimple_call_num_args(), gimple_call_operator_delete_p(), gimple_phi_arg_edge(), gimple_phi_num_args(), gimple_phi_result(), gimple_return_retval(), gimple_vuse(), i, basic_block_def::index, is_gimple_call(), is_gimple_min_invariant(), keep_all_vdefs_p(), longest_chain, mark_aliased_reaching_defs_necessary(), mark_all_reaching_defs_necessary(), mark_control_dependent_edges_necessary(), mark_last_stmt_necessary(), mark_operand_necessary(), nr_walks, NULL_TREE, PHI_ARG_DEF, print_gimple_stmt(), ref_may_be_aliased(), SSA_NAME_DEF_STMT, SSA_OP_USE, TDF_DETAILS, TDF_SLIM, total_chain, TREE_CODE, TREE_OPERAND, TREE_VALUE, valid_new_delete_pair_p(), virtual_operand_p(), visited, visited_control_parents, and worklist.

Referenced by perform_tree_ssa_dce().

◆ ref_may_be_aliased()

static bool ref_may_be_aliased ( tree ref)
static
Return true if REF is based on an aliased base, otherwise false.   

References DECL_P, ggc_alloc(), handled_component_p(), may_be_aliased(), TREE_CODE, and TREE_OPERAND.

Referenced by mark_all_reaching_defs_necessary_1(), and propagate_necessity().

◆ remove_dead_phis()

◆ remove_dead_stmt()

◆ simple_dce_from_worklist()

◆ sort_phi_args()

static int sort_phi_args ( const void * a_,
const void * b_ )
static
Sort PHI argument values for make_forwarders_with_degenerate_phis.   

References a, b, and ggc_alloc().

Referenced by make_forwarders_with_degenerate_phis().

◆ tree_dce_done()

static void tree_dce_done ( bool aggressive)
static

◆ tree_dce_init()

static void tree_dce_init ( bool aggressive)
static
Initialization for this pass.  Set up the used data structures.   

References bb_contains_live_stmts, bitmap_clear(), cfg_altered, cfun, ggc_alloc(), last_basic_block_for_fn, last_stmt_necessary, num_ssa_names, processed, sbitmap_alloc(), and worklist.

Referenced by perform_tree_ssa_dce().

◆ tree_ssa_cd_dce()

static unsigned int tree_ssa_cd_dce ( void )
static

◆ tree_ssa_dce()

static unsigned int tree_ssa_dce ( void )
static
Pass entry points.   

References perform_tree_ssa_dce().

◆ valid_new_delete_pair_p()

static bool valid_new_delete_pair_p ( gimple * new_call,
gimple * delete_call )
static
Return that NEW_CALL and DELETE_CALL are a valid pair of new
and delete  operators.   

References DECL_ASSEMBLER_NAME, ggc_alloc(), gimple_call_fndecl(), and valid_new_delete_pair_p().

Referenced by new_delete_mismatch_p(), propagate_necessity(), and valid_new_delete_pair_p().

Variable Documentation

◆ bb_contains_live_stmts

sbitmap bb_contains_live_stmts
static

◆ bb_postorder

int* bb_postorder
static
When non-NULL holds map from basic block index into the postorder.   

Referenced by cmp_bb_postorder(), eliminate_unnecessary_stmts(), remove_dead_stmt(), and sort_bbs_postorder().

◆ cd

control_dependences* cd
static
Before we can determine whether a control branch is dead, we need to
compute which blocks are control dependent on which edges.

We expect each block to be control dependent on very few edges so we
use a bitmap for each block recording its edges.  An array holds the
bitmap.  The Ith bit in the bitmap is set if that block is dependent
on the Ith edge.   

Referenced by add_multivariate_self_dist(), loop_distribution::build_rdg(), control_parents_preserved_p(), create_edge_for_control_dependence(), create_rdg_cd_edges(), deps_ok_for_redirect_from_bb_to_bb(), loop_distribution::distribute_loop(), loop_distribution::execute(), gcd_of_steps_may_divide_p(), identifier_to_locale(), mark_control_dependent_edges_necessary(), perform_tree_ssa_dce(), and tree_dce_done().

◆ cfg_altered

bool cfg_altered
static
TRUE if this pass alters the CFG (by removing control statements).
FALSE otherwise.

If this pass alters the CFG, then it will arrange for the dominators
to be recomputed.   

Referenced by eliminate_unnecessary_stmts(), perform_tree_ssa_dce(), and tree_dce_init().

◆ chain_ovfl

◆ last_stmt_necessary

sbitmap last_stmt_necessary
static
Vector indicating that the last statement of a basic block has already
been marked as necessary.   

Referenced by control_parents_preserved_p(), mark_last_stmt_necessary(), tree_dce_done(), and tree_dce_init().

◆ longest_chain

◆ nr_walks

◆ processed

sbitmap processed
static
Vector indicating an SSA name has already been processed and marked
as necessary.   

Referenced by eliminate_unnecessary_stmts(), fast_dce(), mark_all_reaching_defs_necessary_1(), mark_operand_necessary(), loop_distribution::rdg_build_partitions(), tree_dce_done(), and tree_dce_init().

◆ stats

struct stmt_stats stats
static

◆ total_chain

◆ visited

bitmap visited = NULL
static

Referenced by add_partitioned_vars_to_ptset(), add_type_duplicate(), strlen_pass::before_dom_children(), vect_optimize_slp_pass::build_vertices(), vect_optimize_slp_pass::build_vertices(), check_reduction_path(), chrec_contains_symbols(), chrec_contains_symbols(), chrec_contains_symbols_defined_in_loop(), chrec_contains_symbols_defined_in_loop(), chrec_contains_undetermined(), chrec_contains_undetermined(), cleanup_control_flow_pre(), uninit_analysis::collect_phi_def_edges(), compute_topo_order(), copy_gimple_seq_and_replace_locals(), determine_known_aggregate_parts(), dfs_enumerate_from(), dfs_find_deadend(), do_invalidate(), do_rpo_vn_1(), dot_slp_tree(), dot_slp_tree(), draw_cfg_nodes_no_loops(), dse_classify_store(), rpo_elim::eliminate_avail(), expr_expected_value(), expr_expected_value_1(), find_always_executed_bbs(), find_comparison_args(), ana::exploded_graph::find_previous_entry_to(), find_vdef_in_loop(), fold_marked_statements(), get_continuation_for_phi(), get_loop_body_in_bfs_order(), get_loop_body_in_if_conv_order(), get_loop_hot_path(), get_maxval_strlen(), get_range_strlen(), get_range_strlen(), get_range_strlen_dynamic(), get_range_strlen_dynamic(), get_range_strlen_phi(), get_range_strlen_tree(), insert_clobber_before_stack_restore(), insert_clobbers_for_var(), inverted_rev_post_order_compute(), ipa_lower_emutls(), ipa_polymorphic_call_context::ipa_polymorphic_call_context(), is_addr_local(), uninit_analysis::is_use_guarded(), uninit_analysis::is_use_guarded(), live_worklist(), loe_visit_block(), loop_inverted_rev_post_order_compute(), loop_rev_post_order_compute(), malloc_candidate_p(), malloc_candidate_p_1(), mark_all_reaching_defs_necessary(), mark_dfs_back_edges(), maybe_add_nop_after_section_switch(), maybe_lower_iteration_bound(), maybe_skip_until(), odr_subtypes_equivalent_p(), odr_types_equivalent_p(), odr_types_equivalent_p(), uninit_analysis::overlap(), perform_tree_ssa_dce(), post_order_compute(), pre_and_rev_post_order_compute_fn(), pre_expr_reaches_here_p(), pre_expr_reaches_here_p_work(), pred_blocks_visited_p(), predict_paths_for_bb(), propagate_necessity(), reachable_at_most_once(), remove_reachable_equiv_notes(), rev_post_order_and_mark_dfs_back_seme(), run_rpo_vn(), should_hoist_expr_to_dom(), single_pred_before_succ_order(), SSA_VAL(), starts_infinite_loop_p(), jump_threader::thread_across_edge(), jump_threader::thread_around_empty_blocks(), jump_threader::thread_through_normal_block(), topo_visit(), translate_vuse_through_block(), tree_contains_chrecs(), tree_contains_chrecs(), unshare_body(), update_alias_info_with_stack_vars(), vect_analyze_slp(), vect_bb_slp_mark_live_stmts(), vect_bb_slp_mark_live_stmts(), vect_bb_slp_scalar_cost(), vect_bb_vectorization_profitable_p(), vect_gather_slp_loads(), vect_gather_slp_loads(), vect_mark_slp_stmts(), vect_mark_slp_stmts(), vect_mark_slp_stmts_relevant(), vect_mark_slp_stmts_relevant(), vect_match_slp_patterns(), vect_match_slp_patterns_2(), vect_print_slp_graph(), vect_print_slp_graph(), vect_remove_slp_scalar_calls(), vect_remove_slp_scalar_calls(), vect_slp_analyze_operations(), vect_slp_gather_vectorized_scalar_stmts(), vect_slp_prune_covered_roots(), verify_eh_throw_stmt_node(), verify_gimple_in_cfg(), verify_loop_structure(), verify_node_sharing_1(), verify_ssa(), verify_vssa(), visit_hist(), visit_phi(), vt_stack_adjustments(), vuse_valueize(), walk_aliased_vdefs(), walk_aliased_vdefs_1(), walk_non_aliased_vuses(), and walk_ssa_copies().

◆ visited_control_parents

sbitmap visited_control_parents
static
Vector indicating that a basic block has already had all the edges
processed that it is control dependent on.   

Referenced by control_parents_preserved_p(), mark_control_dependent_edges_necessary(), perform_tree_ssa_dce(), propagate_necessity(), and tree_dce_done().

◆ worklist