GCC Middle and Back End API Reference
basic-block.h File Reference
#include <profile-count.h>
#include "cfg-flags.def"
Include dependency graph for basic-block.h:

Go to the source code of this file.

Data Structures

class  edge_def
 
union  edge_def::edge_def_insns
 
struct  rtl_bb_info
 
struct  gimple_bb_info
 
struct  basic_block_def
 
union  basic_block_def::basic_block_il_dependent
 
struct  edge_iterator
 

Macros

#define DEF_EDGE_FLAG(NAME, IDX)
 
#define EDGE_ALL_FLAGS   ((LAST_CFG_EDGE_FLAG - 1) * 2 - 1)
 
#define EDGE_COMPLEX    (EDGE_ABNORMAL | EDGE_ABNORMAL_CALL | EDGE_EH | EDGE_PRESERVE)
 
#define BB_FREQ_MAX   10000
 
#define DEF_BASIC_BLOCK_FLAG(NAME, IDX)
 
#define BB_ALL_FLAGS   ((LAST_CFG_BB_FLAG - 1) * 2 - 1)
 
#define BB_FLAGS_TO_PRESERVE
 
#define BB_UNPARTITIONED   0
 
#define BB_PARTITION(bb)
 
#define BB_SET_PARTITION(bb, part)
 
#define BB_COPY_PARTITION(dstbb, srcbb)
 
#define ENTRY_BLOCK_PTR_FOR_FN(FN)
 
#define EXIT_BLOCK_PTR_FOR_FN(FN)
 
#define basic_block_info_for_fn(FN)
 
#define n_basic_blocks_for_fn(FN)
 
#define n_edges_for_fn(FN)
 
#define last_basic_block_for_fn(FN)
 
#define label_to_block_map_for_fn(FN)
 
#define profile_status_for_fn(FN)
 
#define BASIC_BLOCK_FOR_FN(FN, N)
 
#define SET_BASIC_BLOCK_FOR_FN(FN, N, BB)
 
#define FOR_BB_BETWEEN(BB, FROM, TO, DIR)
 
#define FOR_EACH_BB_FN(BB, FN)
 
#define FOR_EACH_BB_REVERSE_FN(BB, FN)
 
#define FOR_BB_INSNS(BB, INSN)
 
#define FOR_BB_INSNS_SAFE(BB, INSN, CURR)
 
#define FOR_BB_INSNS_REVERSE(BB, INSN)
 
#define FOR_BB_INSNS_REVERSE_SAFE(BB, INSN, CURR)
 
#define FOR_ALL_BB_FN(BB, FN)
 
#define BB_HEAD(B)
 
#define BB_END(B)
 
#define BB_HEADER(B)
 
#define BB_FOOTER(B)
 
#define ENTRY_BLOCK   (0)
 
#define EXIT_BLOCK   (1)
 
#define NUM_FIXED_BLOCKS   (2)
 
#define EDGE_INDEX_NO_EDGE   -1
 
#define EDGE_INDEX(el, pred, succ)
 
#define INDEX_EDGE_PRED_BB(el, index)
 
#define INDEX_EDGE_SUCC_BB(el, index)
 
#define INDEX_EDGE(el, index)
 
#define NUM_EDGES(el)
 
#define FALLTHRU_EDGE(bb)
 
#define BRANCH_EDGE(bb)
 
#define EDGE_FREQUENCY(e)
 
#define GCOV_COMPUTE_SCALE(num, den)
 
#define EDGE_CRITICAL_P(e)
 
#define EDGE_COUNT(ev)
 
#define EDGE_I(ev, i)
 
#define EDGE_PRED(bb, i)
 
#define EDGE_SUCC(bb, i)
 
#define ei_start(iter)
 
#define ei_last(iter)
 
#define FOR_EACH_EDGE(EDGE, ITER, EDGE_VEC)
 
#define CLEANUP_EXPENSIVE
 
#define CLEANUP_CROSSJUMP   2 /* Do crossjumping. @endverbatim */
 
#define CLEANUP_POST_REGSTACK
 
#define CLEANUP_THREADING   8 /* Do jump threading. @endverbatim */
 
#define CLEANUP_NO_INSN_DEL
 
#define CLEANUP_CFGLAYOUT   32 /* Do cleanup in cfglayout mode. @endverbatim */
 
#define CLEANUP_CFG_CHANGED   64 /* The caller changed the CFG. @endverbatim */
 
#define CLEANUP_NO_PARTITIONING   128 /* Do not try to fix partitions. @endverbatim */
 
#define CLEANUP_FORCE_FAST_DCE
 

Enumerations

enum  cfg_edge_flags { LAST_CFG_EDGE_FLAG }
 
enum  cfg_bb_flags { LAST_CFG_BB_FLAG }
 

Functions

 STATIC_ASSERT (sizeof(rtl_bb_info) >=sizeof(gimple_bb_info))
 
bool single_succ_p (const_basic_block bb)
 
bool single_pred_p (const_basic_block bb)
 
edge single_succ_edge (const_basic_block bb)
 
edge single_pred_edge (const_basic_block bb)
 
basic_block single_succ (const_basic_block bb)
 
basic_block single_pred (const_basic_block bb)
 
vec< edge, va_gc > * ei_container (edge_iterator i)
 
edge_iterator ei_start_1 (vec< edge, va_gc > **ev)
 
edge_iterator ei_last_1 (vec< edge, va_gc > **ev)
 
bool ei_end_p (edge_iterator i)
 
bool ei_one_before_end_p (edge_iterator i)
 
void ei_next (edge_iterator *i)
 
void ei_prev (edge_iterator *i)
 
edge ei_edge (edge_iterator i)
 
edge ei_safe_edge (edge_iterator i)
 
bool ei_cond (edge_iterator ei, edge *p)
 
bool bb_in_transaction (basic_block bb)
 
bool bb_has_eh_pred (basic_block bb)
 
bool bb_has_abnormal_pred (basic_block bb)
 
edge find_fallthru_edge (vec< edge, va_gc > *edges)
 
void check_probability (int prob)
 
int combine_probabilities (int prob1, int prob2)
 
gcov_type apply_scale (gcov_type freq, gcov_type scale)
 
gcov_type apply_probability (gcov_type freq, int prob)
 
int inverse_probability (int prob1)
 
bool has_abnormal_or_eh_outgoing_edge_p (basic_block bb)
 
bool has_abnormal_call_or_eh_pred_edge_p (basic_block bb)
 

Macro Definition Documentation

◆ BASIC_BLOCK_FOR_FN

#define BASIC_BLOCK_FOR_FN ( FN,
N )
Value:
#define basic_block_info_for_fn(FN)
Definition basic-block.h:196
#define N
Definition gensupport.cc:202

Referenced by add_exit_phis_var(), add_scope_conflicts(), analyze_function_body(), fixup_note_insn_basic_block::apply(), apply_clusters(), apply_opt_in_copies(), associate_equivalences_with_edges(), rt_bb_visited::check(), cleanup_control_flow_pre(), cleanup_tree_cfg_noloop(), compute_antic(), compute_antinout_edge(), compute_available(), compute_laterin(), compute_live_loop_exits(), compute_live_vars(), copy_cfg_body(), copy_phi_node_args(), function_reader::create_edges(), cse_main(), debug_bb_n(), debug_bb_n(), debug_bb_n_slim(), decompose_multiword_subregs(), df_bb_delete(), df_bb_refs_record(), df_bb_replace(), df_chain_create_bb(), df_chain_remove_problem(), df_dump_region(), df_live_bb_local_compute(), df_lr_bb_local_compute(), df_md_bb_local_compute(), df_md_local_compute(), df_md_transfer_function(), df_mir_bb_local_compute(), df_note_bb_compute(), df_rd_bb_local_compute(), df_record_entry_block_defs(), df_record_exit_block_uses(), df_reorganize_refs_by_insn(), df_reorganize_refs_by_reg_by_insn(), df_scan_blocks(), df_set_blocks(), df_update_entry_block_defs(), df_update_exit_block_uses(), df_word_lr_bb_local_compute(), df_worklist_propagate_backward(), df_worklist_propagate_forward(), do_rpo_vn_1(), dominated_by_forbidden(), draw_cfg_nodes_no_loops(), dom_oracle::dump(), equiv_oracle::dump(), rpo_elim::eliminate_avail(), end_recording_case_labels(), same_succ::equal(), execute_tm_mark(), ext_dce_rd_transfer_n(), fast_dce(), find_clusters_1(), find_uses_to_rename(), fix_loop_structure(), flow_loops_find(), get_bb_copy(), get_bb_original(), control_dependences::get_edge_dest(), control_dependences::get_edge_src(), gimple_debug_bb_n(), gimple_flow_call_edges_add(), gimple_purge_all_dead_abnormal_call_edges(), gimple_purge_all_dead_eh_edges(), hoist_code(), init_alias_analysis(), input_bb(), input_cfg(), input_phi(), insert(), insert_one_insn(), insert_phi_nodes_for(), insert_updated_phi_nodes_for(), ipa_merge_profiles(), ipa_tm_scan_irr_function(), label_to_block(), live_worklist(), loop_invariant_motion_in_fun(), lra_create_live_ranges_1(), make_edges(), mark_target_live_regs(), fwd_jt_path_registry::mark_threaded_blocks(), nearest_common_dominator_for_set(), nearest_common_dominator_of_uses(), oacc_do_neutering(), optimize_inline_calls(), optimize_range_tests(), optimize_range_tests_to_bit_test(), optimize_range_tests_var_bound(), param_change_prob(), update_list::pop(), pre_and_rev_post_order_compute_fn(), propagate_freq(), prune_unused_phi_nodes(), ranger_cache::ranger_cache(), regrename_analyze(), regstat_bb_compute_calls_crossed(), remove_unreachable::remove(), remove_unreachable::remove_and_update_globals(), remove_bb(), remove_edge_and_dominated_blocks(), rev_post_order_and_mark_dfs_back_seme(), rewrite_blocks(), rtl_flow_call_edges_add(), same_phi_alternatives(), same_succ_flush_bbs(), same_succ_hash(), set_cluster(), set_livein_block(), ssa_prop_init(), ssa_propagation_engine::ssa_propagate(), tm_memopt_compute_antic(), tree_lower_complex(), tree_unroll_loops_completely(), unloop_loops(), fwd_jt_path_registry::update_cfg(), update_debug_stmts(), update_range_test(), update_worklist(), vect_slp_function(), verify_flow_info(), vn_nary_op_get_predicated_value(), vn_nary_op_insert_into(), and vt_find_locations().

◆ basic_block_info_for_fn

◆ BB_ALL_FLAGS

#define BB_ALL_FLAGS   ((LAST_CFG_BB_FLAG - 1) * 2 - 1)
Bit mask for all basic block flags.   

Referenced by dump_bb_info(), and init_flow().

◆ BB_COPY_PARTITION

#define BB_COPY_PARTITION ( dstbb,
srcbb )
Value:
BB_SET_PARTITION (dstbb, BB_PARTITION (srcbb))
#define BB_SET_PARTITION(bb, part)
Definition basic-block.h:184
#define BB_PARTITION(bb)
Definition basic-block.h:183

Referenced by cfg_layout_duplicate_bb(), cfg_layout_split_edge(), copy_bb(), fix_crossing_conditional_branches(), force_nonfallthru_and_redirect(), handle_simple_exit(), rtl_split_block(), rtl_split_edge(), and try_shrink_wrapping().

◆ BB_END

#define BB_END ( B)
Value:
(B)->il.x.rtl->end_

Referenced by _succ_iter_start(), add_insn_after(), add_labels_and_missing_jumps(), apply_opt_in_copies(), bb_estimate_probability_locally(), bb_has_well_behaved_predecessors(), bb_valid_for_noce_process_p(), find_comparison_dom_walker::before_dom_children(), block_has_only_trap(), block_jumps_and_fallthru(), build_def_use(), can_delete_call(), can_fallthru(), cfg_layout_can_duplicate_bb_p(), cfg_layout_can_merge_blocks_p(), cfg_layout_delete_block(), cfg_layout_duplicate_bb(), cfg_layout_merge_blocks(), cfg_layout_redirect_edge_and_branch(), cfg_layout_split_edge(), cheap_bb_rtx_cost_p(), check_cond_move_block(), check_simple_exit(), cleanup_barriers(), combine_instructions(), combine_stack_adjustments_for_block(), commit_one_edge_insertion(), compute_bb_for_insn(), compute_outgoing_frequencies(), cond_exec_find_if_block(), cond_exec_process_if_block(), construct_exit_block(), contains_no_active_insn_p(), copyprop_hardreg_forward_1(), count_bb_insns(), create_basic_block_structure(), create_preheader(), cse_cc_succs(), cse_condition_code_reg(), cse_extended_basic_block(), cse_find_path(), dead_or_predicable(), decompose_multiword_subregs(), delete_dead_jumptables(), delete_insn(), delete_insn_and_edges(), delete_noop_moves(), discover_loops(), doloop_modify(), doloop_valid_p(), duplicate_computed_gotos(), dw2_fix_up_crossing_landing_pad(), eliminate_partially_redundant_load(), emit_barrier_after_bb(), emit_common_tails_for_components(), emit_insn_after_1(), emit_moves(), emit_nop_for_unique_locus_between(), emit_note_after(), expand_gimple_basic_block(), expand_gimple_cond(), expand_gimple_tailcall(), final_1(), find_active_insn_after(), find_bb_boundaries(), find_cond_trap(), find_if_case_1(), find_if_case_2(), find_implicit_sets(), find_jump_block(), find_many_sub_basic_blocks(), find_moveable_store(), finish_eh_generation(), first_active_insn(), fix_crossing_conditional_branches(), fix_crossing_unconditional_branches(), fix_up_fall_thru_edges(), fixup_abnormal_edges(), fixup_partition_crossing(), fixup_reorder_chain(), flow_find_cross_jump(), flow_find_head_matching_sequence(), force_nonfallthru_and_redirect(), get_bb_avail_insn(), get_last_bb_insn(), guess_outgoing_edge_probabilities(), handle_simple_exit(), indirect_jump_optimize(), insert_insn_end_basic_block(), insert_insn_start_basic_block(), insert_one_insn(), insert_prologue_epilogue_for_components(), insert_var_expansion_initialization(), ira(), last_active_insn(), likely_spilled_retval_p(), lra_inheritance(), lra_process_new_insns(), make_edges(), maybe_duplicate_computed_goto(), merge_blocks_move_predecessor_nojumps(), merge_blocks_move_successor_nojumps(), merge_if_block(), move_invariant_reg(), next_active_insn_bb(), noce_find_if_block(), noce_process_if_block(), outgoing_edges_match(), function_reader::parse_block(), peep2_attempt(), peephole2_optimize(), prepare_shrink_wrap(), print_rtl_with_bb(), propagate_for_debug(), prune_expressions(), purge_dead_edges(), purge_dead_tablejump_edges(), record_effective_endpoints(), redirect_branch_edge(), reload_cse_regs_1(), remove_insn(), remove_reachable_equiv_notes(), reorder_basic_blocks_simple(), reorder_insns(), replace_store_insn(), reposition_prologue_and_epilogue_notes(), rotate_loop(), rtl_block_ends_with_call_p(), rtl_block_ends_with_condjump_p(), rtl_can_merge_blocks(), rtl_can_remove_branch_p(), rtl_dump_bb(), rtl_flow_call_edges_add(), rtl_lv_add_condition_to_bb(), rtl_merge_blocks(), rtl_predict_edge(), rtl_predicted_by_p(), rtl_split_block(), rtl_split_edge(), rtl_tidy_fallthru_edge(), rtl_verify_bb_insn_chain(), rtl_verify_bb_insns(), rtl_verify_bb_layout(), rtl_verify_edges(), rtl_verify_fallthru(), save_call_clobbered_regs(), scan_loop(), set_edge_can_fallthru_flag(), simplify_using_initial_values(), simulate_backwards_to_point(), sjlj_emit_function_enter(), sjlj_fix_up_crossing_landing_pad(), skip_insns_after_block(), split_all_insns(), split_edge_and_insert(), store_killed_after(), thread_jump(), thread_prologue_and_epilogue_insns(), tidy_fallthru_edges(), trivially_empty_bb_p(), try_crossjump_bb(), try_crossjump_to_edge(), try_forward_edges(), try_head_merge_bb(), try_optimize_cfg(), try_redirect_by_replacing_jump(), try_shrink_wrapping(), try_simplify_condjump(), unify_moves(), unique_locus_on_edge_between_p(), update_bb_for_insn(), update_br_prob_note(), update_cfg_for_uncondjump(), update_crossing_jump_flags(), update_equiv_regs(), vt_stack_adjustments(), and walk_to_nondebug_insn().

◆ BB_FLAGS_TO_PRESERVE

#define BB_FLAGS_TO_PRESERVE
Value:
(BB_DISABLE_SCHEDULE | BB_RTL | BB_NON_LOCAL_GOTO_TARGET \
| BB_HOT_PARTITION | BB_COLD_PARTITION)
Bit mask for all basic block flags that must be preserved.  These are
the bit masks that are *not* cleared by clear_bb_flags.   

Referenced by clear_bb_flags().

◆ BB_FOOTER

◆ BB_FREQ_MAX

#define BB_FREQ_MAX   10000

◆ BB_HEAD

#define BB_HEAD ( B)
Value:
(B)->il.x.head_
Stuff for recording basic block info.   
For now, these will be functions (so that they can include checked casts
to rtx_insn.   Once the underlying fields are converted from rtx
to rtx_insn, these can be converted back to macros.   

Referenced by add_insn_before(), apply_opt_in_copies(), bb_note(), find_comparison_dom_walker::before_dom_children(), block_jumps_and_fallthru(), block_label(), build_def_use(), build_insn_chain(), build_store_vectors(), can_fallthru(), cfg_layout_can_duplicate_bb_p(), cfg_layout_can_merge_blocks_p(), cfg_layout_delete_block(), cfg_layout_duplicate_bb(), cfg_layout_merge_blocks(), cfg_layout_redirect_edge_and_branch(), cheap_bb_rtx_cost_p(), combine_and_move_insns(), combine_instructions(), combine_stack_adjustments_for_block(), combine_var_copies_in_loop_exit(), commit_one_edge_insertion(), compute_alignments(), compute_bb_for_insn(), compute_hash_table_work(), cond_exec_find_if_block(), cond_exec_process_if_block(), contains_no_active_insn_p(), copyprop_hardreg_forward_1(), count_bb_insns(), cprop_jump(), create_basic_block_structure(), cse_cc_succs(), cse_condition_code_reg(), dead_or_predicable(), decompose_multiword_subregs(), delete_insn(), delete_noop_moves(), discover_loops(), distribute_links(), distribute_notes(), doloop_valid_p(), eliminate_partially_redundant_load(), emit_moves(), emit_note_before(), entry_of_function(), equivalent_reg_at_start(), expand_gimple_basic_block(), final_1(), find_active_insn_before(), find_bb_boundaries(), find_call_stack_args(), find_jump_block(), finish_eh_generation(), first_active_insn(), first_insn_after_basic_block_note(), fixup_abnormal_edges(), fixup_partitions(), fixup_reorder_chain(), flow_find_cross_jump(), flow_find_head_matching_sequence(), force_nonfallthru_and_redirect(), free_resource_info(), get_bb_avail_insn(), init_resource_info(), insert_insn_end_basic_block(), insert_insn_start_basic_block(), insert_insn_start_basic_block(), insert_one_insn(), insert_section_boundary_note(), label_for_bb(), last_active_insn(), lra_inheritance(), lra_process_new_insns(), make_edges(), mark_target_live_regs(), maybe_duplicate_computed_goto(), merge_blocks_move_predecessor_nojumps(), merge_blocks_move_successor_nojumps(), function_reader::parse_block(), peephole2_optimize(), prev_active_insn_bb(), print_rtl_with_bb(), purge_dead_edges(), record_effective_endpoints(), redirect_branch_edge(), reg_dead_at_p(), relink_block_chain(), reload_combine(), remove_insn(), remove_reachable_equiv_notes(), rtl_block_ends_with_call_p(), rtl_delete_block(), rtl_dump_bb(), rtl_flow_call_edges_add(), rtl_merge_blocks(), rtl_split_edge(), rtl_tidy_fallthru_edge(), rtl_verify_bb_insn_chain(), rtl_verify_bb_insns(), rtl_verify_edges(), rtl_verify_fallthru(), scan_loop(), skip_insns_after_block(), split_all_insns(), store_killed_before(), thread_jump(), trivially_empty_bb_p(), try_back_substitute_reg(), try_combine(), try_crossjump_to_edge(), try_head_merge_bb(), try_optimize_cfg(), try_redirect_by_replacing_jump(), unique_locus_on_edge_between_p(), update_bb_for_insn(), update_equiv_regs(), vt_emit_notes(), vt_initialize(), vt_stack_adjustments(), and walk_to_nondebug_insn().

◆ BB_HEADER

◆ BB_PARTITION

◆ BB_SET_PARTITION

#define BB_SET_PARTITION ( bb,
part )
Value:
do { \
basic_block bb_ = (bb); \
bb_->flags = ((bb_->flags & ~(BB_HOT_PARTITION|BB_COLD_PARTITION)) \
| (part)); \
} while (0)
struct basic_block_def * basic_block
Definition coretypes.h:355
int flags
Definition basic-block.h:144

Referenced by rt_bb_visited::check(), create_basic_block_structure(), create_eh_forwarder_block(), find_partition_fixes(), find_rarely_executed_basic_blocks_and_crossing_edges(), insert_check_and_trap(), function_reader::parse_block(), and sanitize_hot_paths().

◆ BB_UNPARTITIONED

#define BB_UNPARTITIONED   0
Dummy bitmask for convenience in the hot/cold partitioning code.   

Referenced by create_basic_block_structure(), fixup_partitions(), function_reader::parse_block(), and verify_hot_cold_block_grouping().

◆ BRANCH_EDGE

◆ CLEANUP_CFG_CHANGED

#define CLEANUP_CFG_CHANGED   64 /* The caller changed the CFG. @endverbatim */

◆ CLEANUP_CFGLAYOUT

#define CLEANUP_CFGLAYOUT   32 /* Do cleanup in cfglayout mode. @endverbatim */

◆ CLEANUP_CROSSJUMP

#define CLEANUP_CROSSJUMP   2 /* Do crossjumping. @endverbatim */

Referenced by cleanup_cfg(), and try_optimize_cfg().

◆ CLEANUP_EXPENSIVE

#define CLEANUP_EXPENSIVE
Value:
1 /* Do relatively expensive optimizations
except for edge forwarding @endverbatim */

Referenced by cleanup_cfg(), do_reload(), merge_blocks_move(), rest_of_handle_if_conversion(), rest_of_handle_thread_prologue_and_epilogue(), and try_optimize_cfg().

◆ CLEANUP_FORCE_FAST_DCE

#define CLEANUP_FORCE_FAST_DCE
Value:
0x100 /* Force run_fast_dce to be called
at least once. @endverbatim */

Referenced by cleanup_cfg(), and rest_of_handle_if_conversion().

◆ CLEANUP_NO_INSN_DEL

#define CLEANUP_NO_INSN_DEL
Value:
16 /* Do not try to delete trivially dead
insns. @endverbatim */

Referenced by cleanup_cfg(), and try_optimize_cfg().

◆ CLEANUP_NO_PARTITIONING

#define CLEANUP_NO_PARTITIONING   128 /* Do not try to fix partitions. @endverbatim */

Referenced by try_optimize_cfg().

◆ CLEANUP_POST_REGSTACK

#define CLEANUP_POST_REGSTACK
Value:
4 /* We run after reg-stack and need
to care REG_DEAD notes. @endverbatim */

Referenced by old_insns_match_p().

◆ CLEANUP_THREADING

#define CLEANUP_THREADING   8 /* Do jump threading. @endverbatim */

◆ DEF_BASIC_BLOCK_FLAG

#define DEF_BASIC_BLOCK_FLAG ( NAME,
IDX )
Value:
BB_##NAME = 1 << IDX ,
@ NAME
Definition tree-ssa-pre.cc:242
Masks for basic_block.flags.   

◆ DEF_EDGE_FLAG

#define DEF_EDGE_FLAG ( NAME,
IDX )
Value:
EDGE_##NAME = 1 << IDX ,
Masks for edge.flags.   

◆ EDGE_ALL_FLAGS

#define EDGE_ALL_FLAGS   ((LAST_CFG_EDGE_FLAG - 1) * 2 - 1)
Bit mask for all edge flags.   

Referenced by dump_edge_info(), and init_flow().

◆ EDGE_COMPLEX

◆ EDGE_COUNT

#define EDGE_COUNT ( ev)
Value:
unsigned vec_safe_length(const vec< T, A, vl_embed > *v)
Definition vec.h:685

Referenced by _eligible_successor_edge_p(), crc_symbolic_execution::add_edge(), add_noreturn_fake_exit_edges(), add_scope_conflicts_1(), all_preds_critical_p(), assert_unreachable_fallthru_edge_p(), bb_has_well_behaved_predecessors(), bb_next_bb(), bitmap_intersection_of_preds(), bitmap_intersection_of_succs(), bitmap_union_of_preds(), bitmap_union_of_succs(), block_has_only_trap(), block_jumps_and_fallthru(), builtin_setjmp_setup_bb(), gori_map::calculate_gori(), can_predict_insn_p(), can_remove_branch_p(), cfg_layout_redirect_edge_and_branch(), cleanup_control_flow_pre(), cleanup_empty_eh(), tree_switch_conversion::switch_conversion::collect(), combine_instructions(), combine_predictions_for_bb(), compute_antic_aux(), compute_branch_probabilities(), compute_dominance_frontiers(), compute_live_loop_exits(), compute_outgoing_frequencies(), compute_partial_antic_aux(), cond_exec_find_if_block(), connect_dest(), connect_traces(), construct_exit_block(), construct_init_block(), control_dependences::control_dependences(), copy_bb_p(), copy_phis_for_bb(), create_edge_list(), create_phi_node(), cse_cc_succs(), cse_extended_basic_block(), cse_find_path(), decrease_profile(), delete_basic_block(), df_worklist_propagate_backward(), df_worklist_propagate_forward(), dfs_find_deadend(), dfs_mark_dominating_region(), disconnect_dest(), discover_loop(), do_hoist_insertion(), do_pre_partial_partial_insertion(), do_pre_regular_insertion(), doloop_modify(), dominated_by_p_w_unex(), dse_classify_store(), dse_step1(), dse_step3(), dump_cfg_stats(), dump_implicit_edges(), gimple_outgoing_range::edge_range_p(), ei_end_p(), ei_last_1(), ei_next(), ei_one_before_end_p(), tree_switch_conversion::bit_test_cluster::emit(), emit_common_tails_for_components(), eq_edge_move_lists_p(), estimate_threading_killed_stmts(), execute_early_expand_coro_ifns(), execute_fixup_cfg(), execute_over_cond_phis(), expand_asm_stmt(), expand_case(), expand_oacc_for(), expand_omp_for(), expand_omp_for_generic(), expand_omp_for_ordered_loops(), expand_omp_for_static_chunk(), expand_omp_for_static_nochunk(), expand_omp_sections(), expand_omp_simd(), expand_omp_taskloop_for_inner(), expand_omp_taskloop_for_outer(), find_always_executed_bbs(), find_block_to_duplicate_for_splitting_paths(), find_cond_trap(), find_edge(), find_if_header(), find_implicit_sets(), find_many_sub_basic_blocks(), find_path(), back_threader::find_paths_to_names(), find_split_points(), find_traces_1_round(), find_unswitching_predicates_for_bb(), fix_crossing_conditional_branches(), fix_crossing_unconditional_branches(), fix_up_fall_thru_edges(), fixup_reorder_chain(), fold_marked_statements(), force_nonfallthru_and_redirect(), fuse_loops(), get_all_loop_exits(), get_ws_args_for(), crc_optimization::get_xor_bb_opposite(), gimple_duplicate_sese_tail(), gimple_find_edge_insert_loc(), gimple_lower_bitint(), gimple_predict_edge(), gimple_try_redirect_by_replacing_jump(), gimple_verify_flow_info(), group_case_labels_stmt(), handle_simple_exit(), hardcfr_sibcall_search_preds(), hoist_code(), if_convertible_bb_p(), ifcvt_split_critical_edges(), ipa_icf::sem_function::init(), predicate::init_from_control_deps(), uninit_analysis::init_from_phi_def(), init_separate_shrink_wrap(), input_phi(), insert(), rt_bb_visited::insert_exit_check_on_edge(), insert_into_preds_of_block(), inverted_rev_post_order_compute(), ipa_merge_profiles(), is_feasible_trace(), live_edge_for_reg(), loop_edge_to_cancel(), loop_inverted_rev_post_order_compute(), loop_rev_post_order_compute(), lower_emutls_function_body(), lower_resx(), make_forwarders_with_degenerate_phis(), malloc_candidate_p(), mark_dfs_back_edges(), mark_stmt_if_obviously_necessary(), match_cond_with_binary_phi(), maybe_optimize_guarding_check(), maybe_optimize_range_tests(), remove_unreachable::maybe_register(), back_threader::maybe_thread_block(), merge_blocks(), merge_if_block(), move_block_to_fn(), move_insn_for_shrink_wrap(), move_sese_region_to_fn(), non_eh_succ_edge(), num_loop_branches(), optimize_spaceship(), optimize_stack_restore(), outgoing_edges_match(), output_cfg(), phi_convertible_by_degenerating_args(), poor_ifcvt_pred(), post_order_compute(), pre_and_rev_post_order_compute_fn(), predicate_scalar_phi(), predict_extra_loop_exits(), print_rtl_with_bb(), profile_record_check_consistency(), purge_dead_edges(), ranger_cache::range_from_dom(), recognize_if_then_else(), reload_cse_regs_1(), reload_cse_simplify(), remap_ssa_name(), remove_branch(), remove_forwarder_block_with_phi(), remove_phi_nodes_and_edges_for_unreachable_block(), remove_reachable_equiv_notes(), replace_block_by(), replace_phi_edge_with_variable(), reserve_phi_args_for_new_edge(), returning_call_p(), rev_post_order_and_mark_dfs_back_seme(), rtl_verify_edges(), set_edge_can_fallthru_flag(), should_duplicate_loop_header_p(), shrink_wrap_one_built_in_call_with_conds(), simd_clone_adjust(), single_block_loop_p(), single_noncomplex_succ(), single_pred_p(), single_succ_p(), sink_common_stores_to_bb(), slpeel_tree_duplicate_loop_to_edge_cfg(), spaceship_replacement(), split_loop(), split_paths(), suitable_cond_bb(), tail_duplicate(), fwd_jt_path_registry::thread_block_1(), back_threader::thread_blocks(), thread_jump(), jump_threader::thread_outgoing_edges(), fwd_jt_path_registry::thread_through_loop_header(), tm_memopt_compute_antin(), tm_memopt_compute_avin(), tree_unswitch_loop(), try_crossjump_bb(), try_crossjump_to_edge(), try_head_merge_bb(), try_optimize_cfg(), try_redirect_by_replacing_jump(), try_shrink_wrapping(), try_simplify_condjump(), unify_moves(), update_cfg_for_uncondjump(), update_profile_after_ch(), value_replacement(), vect_analyze_loop_form(), vect_loop_versioning(), vect_transform_loop(), verify_jump_thread(), verify_loop_structure(), verify_phi_args(), rt_bb_visited::visit(), visit_phi(), vn_phi_compute_hash(), vn_phi_eq(), vn_phi_insert(), vn_phi_lookup(), vt_stack_adjustments(), dom_walker::walk(), worker_single_copy(), and worker_single_simple().

◆ EDGE_CRITICAL_P

#define EDGE_CRITICAL_P ( e)

◆ EDGE_FREQUENCY

#define EDGE_FREQUENCY ( e)
Value:
e->count ().to_frequency (cfun)
#define cfun
Definition function.h:478
Return expected execution frequency of the edge E.   

Referenced by add_ranges_and_copies(), bb_to_key(), coalesce_cost_edge(), compare_freqs(), emit_moves(), find_traces_1_round(), ira_loop_edge_freq(), and place_prologue_for_one_component().

◆ EDGE_I

#define EDGE_I ( ev,
i )
Value:
(*ev)[(i)]
i
Definition poly-int.h:776

Referenced by ei_edge(), eq_edge_move_lists_p(), remove_reachable_equiv_notes(), and unify_moves().

◆ EDGE_INDEX

#define EDGE_INDEX ( el,
pred,
succ )
Value:
(find_edge_index ((el), (pred), (succ)))
int find_edge_index(struct edge_list *edge_list, basic_block pred, basic_block succ)
Definition cfganal.cc:543
Definition tree-ssa-threadupdate.cc:102
EDGE_INDEX returns an integer index for an edge, or EDGE_INDEX_NO_EDGE
if there is no edge between the 2 basic blocks.   

Referenced by insert_store(), and verify_edge_list().

◆ EDGE_INDEX_NO_EDGE

#define EDGE_INDEX_NO_EDGE   -1
This is the value which indicates no edge is present.   

Referenced by find_edge_index(), insert_store(), and verify_edge_list().

◆ EDGE_PRED

◆ EDGE_SUCC

#define EDGE_SUCC ( bb,
i )
Value:
(*(bb)->succs)[(i)]

Referenced by _eligible_successor_edge_p(), crc_symbolic_execution::add_edge(), assert_unreachable_fallthru_edge_p(), substitute_and_fold_dom_walker::before_dom_children(), bitmap_intersection_of_succs(), bitmap_union_of_succs(), builtin_setjmp_setup_bb(), cfg_layout_merge_blocks(), cfg_layout_redirect_edge_and_branch(), check_simple_exit(), compute_added_num_insns(), path_range_query::compute_outgoing_relations(), cond_if_else_store_replacement_1(), connect_loops(), construct_init_block(), create_canonical_iv(), delete_basic_block(), dfs_find_deadend(), discover_loop(), eliminate_dom_walker::eliminate_stmt(), emit_nop_for_unique_locus_between(), execute_over_cond_phis(), expand_oacc_for(), expand_omp_sections(), expand_omp_simd(), extract_true_false_edges_from_block(), find_block_to_duplicate_for_splitting_paths(), find_if_header(), find_split_points(), find_unswitching_predicates_for_bb(), fix_crossing_conditional_branches(), fix_crossing_unconditional_branches(), fix_up_fall_thru_edges(), simplify_using_ranges::fold_cond(), forward_propagate_into_gimple_cond(), forwarder_block_p(), get_cond_invariant_branch(), crc_optimization::get_xor_bb_opposite(), gimple_duplicate_sese_tail(), gimple_find_edge_insert_loc(), gimple_try_redirect_by_replacing_jump(), hoist_code(), ip_normal_pos(), ipa_merge_profiles(), iv_elimination_compare(), loop_edge_to_cancel(), lower_resx(), match_simplify_replacement(), may_eliminate_iv(), maybe_diag_stxncpy_trunc(), maybe_optimize_guarding_check(), maybe_optimize_range_tests(), remove_unreachable::maybe_register(), merge_blocks(), merge_if_block(), minmax_replacement(), non_eh_succ_edge(), optimize_mask_stores(), optimize_spaceship(), outgoing_edges_match(), patch_loop_exit(), fold_using_range::range_of_range_op(), recognize_if_then_else(), record_edge_info(), remap_ssa_name(), remove_branch(), remove_exits_and_undefined_stmts(), remove_phi_nodes_and_edges_for_unreachable_block(), remove_redundant_iv_tests(), reorder_basic_blocks_simple(), replace_phi_edge_with_variable(), rev_post_order_and_mark_dfs_back_seme(), rtl_can_remove_branch_p(), rtl_extract_cond_bb_edges(), rtl_merge_blocks(), set_edge_can_fallthru_flag(), should_duplicate_loop_header_p(), shrink_wrap_one_built_in_call_with_conds(), simplify_loop_version(), single_block_loop_p(), single_noncomplex_succ(), single_succ_edge(), slpeel_add_loop_guard(), spaceship_replacement(), split_paths(), ssa_fix_duplicate_block_edges(), suitable_cond_bb(), jump_threader::thread_outgoing_edges(), tm_memopt_compute_antin(), tree_forwarder_block_p(), tree_unswitch_single_loop(), try_crossjump_bb(), try_head_merge_bb(), try_redirect_by_replacing_jump(), try_unroll_loop_completely(), unique_locus_on_edge_between_p(), unroll_loop_constant_iterations(), unroll_loop_runtime_iterations(), unswitch_predicate::unswitch_predicate(), update_profile_after_ch(), update_profile_after_ifcombine(), vect_do_peeling(), vect_loop_versioning(), vectorizable_early_exit(), and rt_bb_visited::visit().

◆ ei_last

#define ei_last ( iter)
Value:
ei_last_1 (&(iter))
edge_iterator ei_last_1(vec< edge, va_gc > **ev)
Definition basic-block.h:396

◆ ei_start

#define ei_start ( iter)
Value:
ei_start_1 (&(iter))
edge_iterator ei_start_1(vec< edge, va_gc > **ev)
Definition basic-block.h:383

Referenced by _succ_iter_start(), bypass_block(), cleanup_control_expr_graph(), cleanup_control_flow_bb(), cleanup_control_flow_pre(), cleanup_empty_eh(), cleanup_empty_eh_merge_phis(), combine_blocks(), dfs_mark_dominating_region(), disconnect_src(), dw2_fix_up_crossing_landing_pad(), eliminate_unnecessary_stmts(), emit_insn_at_entry(), emit_to_new_bb_before(), ipa_icf::sem_function::equals_private(), expand_gimple_tailcall(), expand_phi_nodes(), fixup_reorder_chain(), force_nonfallthru_and_redirect(), force_one_exit_fallthru(), gimple_purge_dead_abnormal_call_edges(), gimple_purge_dead_eh_edges(), ipa_icf::sem_function::init(), input_function(), inverted_rev_post_order_compute(), isolate_path(), loop_inverted_rev_post_order_compute(), loop_rev_post_order_compute(), make_forwarder_block(), mark_dfs_back_edges(), maybe_duplicate_computed_goto(), move_sese_region_to_fn(), post_order_compute(), pre_and_rev_post_order_compute_fn(), tree_switch_conversion::switch_conversion::prune_bbs(), purge_dead_edges(), purge_dead_tablejump_edges(), remove_ctrl_stmt_and_useless_edges(), remove_fake_predecessors(), remove_forwarder_block(), remove_reachable_equiv_notes(), rev_post_order_and_mark_dfs_back_seme(), simplify_gimple_switch_label_vec(), sjlj_fix_up_crossing_landing_pad(), thread_prologue_and_epilogue_insns(), try_forward_edges(), try_shrink_wrapping(), verify_sese(), and vt_stack_adjustments().

◆ ENTRY_BLOCK

◆ ENTRY_BLOCK_PTR_FOR_FN

#define ENTRY_BLOCK_PTR_FOR_FN ( FN)
Value:
((FN)->cfg->x_entry_block_ptr)
Defines for accessing the fields of the CFG structure for function FN.   

Referenced by add_labels_and_missing_jumps(), adjust_cfg_counts(), autofdo::afdo_annotate_cfg(), alloc_aux_for_edges(), analyze_function_body(), asan_maybe_insert_dynamic_shadow_at_function_entry(), assemble_start_function(), rt_bb_visited::bb2idx(), bb_loop_header_p(), dom_walker::bb_reachable(), bb_to_key(), loop_distribution::bb_top_order_init(), bitmap_intersection_of_preds(), bitmap_union_of_preds(), block_before_loop(), ranger_cache::block_range(), bound_difference(), branch_prob(), build_and_add_sum(), build_gimple_cfg(), build_omp_regions(), build_ssa_conflict_graph(), bypass_conditional_jumps(), cached_make_edge(), can_duplicate_block_p(), cfg_layout_can_merge_blocks_p(), cfg_layout_redirect_edge_and_branch(), cfg_layout_split_edge(), array_bounds_checker::check(), rt_bb_visited::check(), check_bb_profile(), cleanup_control_flow_pre(), clear_aux_for_edges(), combine_instructions(), combine_reloads(), commit_edge_insertions(), commit_one_edge_insertion(), compact_blocks(), compute_alignments(), compute_antinout_edge(), compute_avail(), compute_available(), compute_bb_predicates(), compute_branch_probabilities(), compute_call_stmt_bb_frequency(), compute_dominance_frontiers(), compute_earliest(), compute_farthest(), compute_function_frequency(), compute_laterin(), compute_live_loop_exits(), compute_nearerout(), compute_rev_insert_delete(), connect_traces(), consider_split(), construct_init_block(), vect_optimize_slp_pass::containing_loop(), contains_no_active_insn_p(), control_dependences::control_dependences(), copy_body(), copy_cfg_body(), correct_negative_edge_counts(), create_edge_list(), create_fixup_graph(), function_reader::create_function(), create_preheader(), dead_or_predicable(), default_ira_callee_saved_register_cost_scale(), delete_unreachable_blocks(), delete_unreachable_blocks_update_callgraph(), determine_dominators_for_sons(), determine_unlikely_bbs(), determine_value_range(), df_entry_block_defs_collect(), disambiguate_multiple_latches(), do_reassoc(), do_rpo_vn_1(), drop_profile(), profile_count::dump(), dump_function_to_file(), eliminate_partially_redundant_loads(), eliminate_tail_call(), eliminate_unnecessary_stmts(), emit_insn_at_entry(), entered_from_non_parent_p(), entry_of_function(), ana::supernode::entry_p(), ranger_cache::entry_range(), estimate_bb_frequencies(), estimate_loops(), execute_fixup_cfg(), execute_split_functions(), ranger_cache::exit_range(), expand_phi_nodes(), expensive_function_p(), ranger_cache::fill_block_cache(), find_always_executed_bbs(), find_basic_block(), find_bb_boundaries(), find_bbs_reachable_by_hot_paths(), find_dummy_reload(), find_hard_regno_for_1(), find_rarely_executed_basic_blocks_and_crossing_edges(), find_spanning_tree(), find_split_points(), find_traces(), find_traces_1_round(), find_unreachable_blocks(), finish_eh_generation(), fixup_fallthru_exit_predecessor(), fixup_partition_crossing(), fixup_reorder_chain(), flow_bb_inside_loop_p(), fold_marked_statements(), force_edge_cold(), force_nonfallthru_and_redirect(), free_cfg(), gate_tm_init(), get_exec_counts(), get_last_alloca_addr(), get_last_value(), get_last_value_validate(), ana::supergraph::get_node_for_function_entry(), gimple_account_profile_record(), gimple_can_merge_blocks_p(), gimple_find_edge_insert_loc(), gimple_gen_ic_func_profiler(), gimple_gen_time_profiler(), gimple_lower_bitint(), gimple_predict_edge(), gimple_redirect_edge_and_branch(), gimple_verify_flow_info(), gimplify_size_expressions(), gsi_commit_edge_inserts(), gsi_prev_dom_bb_nondebug(), hoist_code(), improve_allocation(), in_loop_p(), init_empty_tree_cfg_for_function(), init_flow(), init_loops_structure(), init_lowered_empty_function(), initialize_cfun(), initialize_constant_pool_replacements(), initialize_parameter_reductions(), inline_transform(), input_cfg(), input_function(), rt_bb_visited::insert_exit_check_on_edge(), insert_updated_phi_nodes_for(), instrument_edges(), instrument_func_entry(), inverted_rev_post_order_compute(), ipa_analyze_node(), ipa_merge_profiles(), ipa_profile_generate_summary(), ipa_simd_modify_function_body(), ipa_simd_modify_stmt_ops(), ipa_tm_scan_irr_function(), ipa_tm_transform_clone(), ipcp_transform_function(), ira_loop_tree_body_rev_postorder(), iterate_fix_dominators(), live_on_entry(), live_on_exit(), loop_preheader_edge(), lra_create_live_ranges_1(), make_blocks(), make_edges(), make_edges(), mark_control_dependent_edges_necessary(), mark_dfs_back_edges(), mark_irreducible_loops(), mark_target_live_regs(), maybe_hot_count_p(), merge_blocks_move(), move_sese_region_to_fn(), nearest_common_dominator_of_uses(), oacc_entry_exit_ok(), oacc_entry_exit_single_gang(), oacc_loop_discovery(), omp_sese_discover_pars(), one_cprop_pass(), output_cfg(), param_change_prob(), post_order_compute(), pre_and_rev_post_order_compute_fn(), pre_expr_reaches_here_p_work(), print_edge_list(), print_loops(), profile_record_check_consistency(), propagate_necessity(), propagate_unlikely_bbs_forward(), prune_bbs_to_update_dominators(), push_reload(), ranger_cache::range_from_dom(), reachable_at_most_once(), read_profile_edge_counts(), cgraph_edge::rebuild_edges(), rebuild_frequencies(), record_modified(), reg_nonzero_bits_for_combine(), reg_num_sign_bit_copies_for_combine(), register_division_in(), regno_clobbered_at_setjmp(), relink_block_chain(), reload_cse_regs_1(), remap_ssa_name(), remove_bb(), remove_fake_edges(), reorder_basic_blocks_simple(), ipa_param_body_adjustments::reset_debug_stmts(), rewrite_debug_stmt_uses(), rtl_account_profile_record(), rtl_block_empty_p(), rtl_can_merge_blocks(), rtl_split_edge(), rtl_verify_bb_layout(), rtl_verify_edges(), rtl_verify_fallthru(), sanopt_optimize(), set_bb_counts(), control_dependences::set_control_dependence_map_bit(), ranger_cache::set_global_range(), set_nonzero_bits_and_sign_copies(), set_var_live_on_entry(), should_hoist_expr_to_dom(), simd_clone_adjust(), simplify_using_initial_conditions(), simplify_using_initial_values(), single_pred_before_succ_order(), sjlj_emit_function_enter(), slsr_process_phi(), split_critical_edges(), split_live_ranges_for_shrink_wrap(), spread_components(), ssa_propagation_engine::ssa_propagate(), substitute_and_fold_engine::substitute_and_fold(), thread_prologue_and_epilogue_insns(), tidy_fallthru_edges(), tm_region_init(), tree_forwarder_block_p(), tree_function_versioning(), tree_optimize_tail_calls_1(), try_crossjump_to_edge(), try_optimize_cfg(), try_shrink_wrapping(), unlikely_executed_bb_p(), update_max_bb_count(), update_parameter_components(), update_ssa(), vect_loop_dist_alias_call(), vect_slp_function(), vect_slp_node_weight(), verify_edge_list(), verify_flow_info(), verify_live_on_entry(), verify_loop_structure(), cgraph_node::verify_node(), verify_non_ssa_vars(), verify_ssa(), rt_bb_visited::vindex(), rt_bb_visited::visit(), vt_add_function_parameter(), vt_find_locations(), vt_initialize(), vt_stack_adjustments(), dom_walker::walk(), walk_to_nondebug_insn(), warn_return_addr_local(), warn_uninit_phi_uses(), and warn_uninitialized_vars().

◆ EXIT_BLOCK

◆ EXIT_BLOCK_PTR_FOR_FN

#define EXIT_BLOCK_PTR_FOR_FN ( FN)
Value:
((FN)->cfg->x_exit_block_ptr)

Referenced by _succ_iter_cond(), _succ_iter_start(), add_control_edge(), add_labels_and_missing_jumps(), add_noreturn_fake_exit_edges(), adjust_cfg_counts(), autofdo::afdo_annotate_cfg(), alloc_aux_for_edges(), apply_return_prediction(), assume_query::assume_query(), rt_bb_visited::bb2idx(), bb_is_just_return(), bitmap_intersection_of_succs(), bitmap_union_of_succs(), block_has_only_trap(), block_label(), branch_prob(), bypass_block(), bypass_conditional_jumps(), cached_make_edge(), can_duplicate_block_p(), can_fallthru(), cfg_layout_can_merge_blocks_p(), cfg_layout_delete_block(), cfg_layout_duplicate_bb(), cfg_layout_split_edge(), cfun_returns(), rt_bb_visited::check(), check_bb_profile(), cleanup_control_flow_pre(), clear_aux_for_edges(), commit_edge_insertions(), commit_one_edge_insertion(), compact_blocks(), compute_alignments(), compute_antic(), compute_antinout_edge(), compute_available(), compute_bb_predicates(), compute_branch_probabilities(), compute_code_hoist_vbeinout(), compute_control_dep_chain_pdom(), compute_earliest(), compute_farthest(), compute_insert_delete(), compute_laterin(), compute_nearerout(), cond_exec_find_if_block(), connect_infinite_loops_to_exit(), connect_traces(), consider_split(), construct_exit_block(), construct_init_block(), contains_no_active_insn_p(), control_dependences::control_dependences(), copy_cfg_body(), copy_edges_for_bb(), could_fall_through(), cprop_jump(), create_edge_list(), create_eh_forwarder_block(), function_reader::create_function(), cse_cc_succs(), cse_find_path(), dead_or_predicable(), delete_unreachable_blocks(), delete_unreachable_blocks_update_callgraph(), determine_unlikely_bbs(), df_exit_block_uses_collect(), df_lr_confluence_0(), discover_loop(), disqualify_problematic_components(), distribute_links(), do_reassoc(), draw_cfg_nodes_for_loop(), dse_step1(), eliminate_partially_redundant_loads(), eliminate_tail_call(), eliminate_unnecessary_stmts(), execute_fixup_cfg(), execute_ranger_vrp(), expand_gimple_basic_block(), expand_gimple_tailcall(), expand_omp_for_generic(), expand_phi_nodes(), expand_thunk(), find_always_executed_bbs(), control_dependences::find_control_dependence(), find_if_case_1(), find_implicit_sets(), find_interesting_uses(), find_many_sub_basic_blocks(), find_rarely_executed_basic_blocks_and_crossing_edges(), find_return_bb(), find_spanning_tree(), find_split_points(), find_traces_1_round(), fix_bb_placement(), fix_crossing_conditional_branches(), fix_up_fall_thru_edges(), fixup_fallthru_exit_predecessor(), fixup_new_cold_bb(), fixup_partition_crossing(), fixup_reorder_chain(), flow_bb_inside_loop_p(), fold_marked_statements(), force_nonfallthru_and_redirect(), force_one_exit_fallthru(), get_loop_body(), get_loop_body_in_bfs_order(), get_loop_body_in_dom_order(), get_loop_body_in_if_conv_order(), get_loop_exit_edges(), get_loop_exit_edges_unique_dests(), ana::supergraph::get_node_for_function_exit(), gimple_can_merge_blocks_p(), gimple_duplicate_bb(), gimple_find_edge_insert_loc(), gimple_flow_call_edges_add(), gimple_verify_flow_info(), handle_simple_exit(), has_nonexceptional_receiver(), has_nonexceptional_receiver(), init_empty_tree_cfg_for_function(), init_flow(), init_loops_structure(), init_lowered_empty_function(), initialize_cfun(), inner_loop_header_p(), insert_prologue_epilogue_for_components(), insert_store(), instrument_func_exit(), inverted_rev_post_order_compute(), ipa_simd_modify_function_body(), ira(), ira_emit(), is_inconsistent(), last_bb_in_partition(), live_edge_for_reg(), live_on_entry(), live_on_exit(), lra_create_live_ranges_1(), lra_inheritance(), lra_process_new_insns(), make_edges(), make_edges_bb(), malloc_candidate_p(), mark_control_dependent_edges_necessary(), mark_dfs_back_edges(), mark_irreducible_loops(), may_use_storent_in_loop_p(), maybe_register_def(), merge_if_block(), move_sese_region_to_fn(), num_loop_branches(), omp_sese_discover_pars(), one_cprop_pass(), optimize_stack_restore(), outgoing_edges_match(), patch_jump_insn(), populate_coalesce_list_for_outofssa(), post_order_compute(), pre_and_rev_post_order_compute_fn(), print_edge_list(), print_loop_title(), profile_record_check_consistency(), propagate_freq(), purge_dead_edges(), ranger_cache::range_from_dom(), relink_block_chain(), remove_unreachable::remove_and_update_globals(), remove_dead_stmt(), remove_edge_and_dominated_blocks(), remove_fake_exit_edges(), remove_path(), remove_reachable_equiv_notes(), reorder_basic_blocks_simple(), reorder_loops(), reposition_prologue_and_epilogue_notes(), ana::supernode::return_p(), returning_call_p(), rotate_loop(), rtl_block_empty_p(), rtl_can_merge_blocks(), rtl_can_remove_branch_p(), rtl_flow_call_edges_add(), rtl_split_edge(), rtl_verify_edges(), rtl_verify_fallthru(), sel_bb_empty_or_nop_p(), control_dependences::set_control_dependence_map_bit(), simd_clone_adjust(), ssa_propagation_engine::simulate_block(), skip_insns_after_block(), split_critical_edges(), split_function(), split_live_ranges_for_shrink_wrap(), spread_components(), thread_prologue_and_epilogue_insns(), tidy_fallthru_edges(), tm_memopt_compute_available(), tree_bb_level_predictions(), tree_estimate_probability_bb(), tree_forwarder_block_p(), tree_function_versioning(), tree_optimize_tail_calls_1(), try_combine(), try_crossjump_bb(), try_forward_edges(), try_head_merge_bb(), try_optimize_cfg(), try_redirect_by_replacing_jump(), try_shrink_wrapping(), try_simplify_condjump(), unlikely_executed_bb_p(), update_bb_reg_pressure(), verify_edge_list(), verify_flow_info(), verify_loop_structure(), rt_bb_visited::vindex(), rt_bb_visited::visit(), vt_find_locations(), vt_initialize(), vt_stack_adjustments(), and dom_walker::walk().

◆ FALLTHRU_EDGE

◆ FOR_ALL_BB_FN

#define FOR_ALL_BB_FN ( BB,
FN )
Value:
for (BB = ENTRY_BLOCK_PTR_FOR_FN (FN); BB; BB = BB->next_bb)
#define ENTRY_BLOCK_PTR_FOR_FN(FN)
Definition basic-block.h:194
Cycles through _all_ basic blocks, even the fake ones (entry and
exit block).   

Referenced by add_scope_conflicts(), adjust_cfg_counts(), autofdo::afdo_calculate_branch_prob(), autofdo::afdo_find_equiv_class(), autofdo::afdo_propagate(), autofdo::afdo_propagate_circuit(), alloc_aux_for_blocks(), analyze_function_body(), calculate_dominance_info(), clear_aux_for_blocks(), clear_bb_flags(), compute_antic(), compute_branch_probabilities(), compute_dom_fast_query(), copy_cfg_body(), create_remat_bb_data(), determine_unlikely_bbs(), df_dump(), df_live_set_all_dirty(), df_live_verify_solution_end(), df_live_verify_solution_start(), df_live_verify_transfer_functions(), df_lr_verify_solution_end(), df_lr_verify_solution_start(), df_lr_verify_transfer_functions(), df_md_local_compute(), df_mir_verify_solution_end(), df_mir_verify_solution_start(), df_reorganize_refs_by_insn(), df_scan_alloc(), df_scan_verify(), df_set_blocks(), do_reload(), draw_cfg_edges(), draw_cfg_nodes_no_loops(), drop_profile(), dse_step1(), dse_step3(), dse_step4(), dse_step6(), dump_flow_info(), emit_common_heads_for_components(), emit_common_tails_for_components(), estimate_loops(), loop_distribution::execute(), execute_oacc_device_lower(), execute_omp_oacc_neuter_broadcast(), fini_pre(), fini_separate_shrink_wrap(), finish_live_solver(), free_dominance_info(), gimple_ranger::gimple_ranger(), init_pre(), init_separate_shrink_wrap(), initiate_live_solver(), inline_transform(), input_function(), insert(), inverted_rev_post_order_compute(), ipa_merge_profiles(), loop_optimizer_finalize(), lra_remat(), lto_prepare_function_for_streaming(), mark_artificial_uses(), oacc_do_neutering(), omp_sese_split_blocks(), output_cfg(), output_function(), profile_record_account_profile(), profile_record_check_consistency(), propagate_unlikely_bbs_forward(), relink_block_chain(), renumber_gimple_stmt_uids(), reorder_basic_blocks_simple(), set_all_edges_as_executable(), split_critical_edges(), spread_components(), stack_protect_return_slot_p(), try_optimize_cfg(), vt_finalize(), and vt_initialize().

◆ FOR_BB_BETWEEN

◆ FOR_BB_INSNS

#define FOR_BB_INSNS ( BB,
INSN )
Value:
for ((INSN) = BB_HEAD (BB); \
(INSN) && (INSN) != NEXT_INSN (BB_END (BB)); \
(INSN) = NEXT_INSN (INSN))
#define BB_END(B)
Definition basic-block.h:255
#define BB_HEAD(B)
Definition basic-block.h:254
rtx_insn * NEXT_INSN(const rtx_insn *insn)
Definition rtl.h:1479
For iterating over insns in basic block.   

Referenced by add_copies(), alloc_mem(), analyze_insns_in_loop(), assign_spill_hard_regs(), average_num_loop_insns(), bb_ok_for_noce_convert_multiple_sets(), bb_valid_for_noce_process_p(), bbs_ok_for_cmove_arith(), build_store_vectors(), bypass_conditional_jumps(), calculate_elim_costs_all_insns(), calculate_equiv_gains(), calculate_gen_cands(), calculate_local_reg_remat_bb_data(), calculate_loop_reg_pressure(), can_dup_for_shrink_wrapping(), change_loop(), check_cond_move_block(), check_rtl(), combine_instructions(), compute_hash_table(), compute_hash_table_work(), compute_ld_motion_mems(), compute_store_table(), cond_move_convert_if_block(), copy_bb_p(), cse_extended_basic_block(), cse_prescan_path(), dead_or_predicable(), decompose_multiword_subregs(), decrease_live_ranges_number(), df_bb_refs_record(), df_bb_regno_first_def_find(), df_chain_create_bb(), df_chain_remove_problem(), df_insn_rescan_all(), df_live_bb_local_compute(), df_md_bb_local_compute(), df_mir_bb_local_compute(), df_recompute_luids(), df_reorganize_refs_by_insn_bb(), df_reorganize_refs_by_reg_by_insn(), df_scan_free_bb_info(), df_scan_start_block(), df_scan_start_dump(), df_update_entry_exit_and_calls(), do_remat(), dse_step1(), eliminate_partially_redundant_loads(), expensive_function_p(), find_exits(), find_invariants_bb(), find_moveable_pseudos(), find_removable_extensions(), get_loop_location(), hoist_code(), init_alias_analysis(), init_elimination(), init_noce_multiple_sets_info(), init_subregs_of_mode(), initialize_uninitialized_regs(), local_cprop_pass(), loop_exit_at_end_p(), make_more_copies(), mark_all_labels(), maybe_duplicate_computed_goto(), noce_convert_multiple_sets_1(), noce_emit_all_but_last(), noce_try_cmove_arith(), num_loop_insns(), one_cprop_pass(), process_bb_for_costs(), process_bb_node_for_hard_reg_moves(), redirect_branch_edge(), referenced_in_one_insn_in_loop_p(), regrename_analyze(), reload_cse_regs_1(), remove_scratches(), remove_scratches(), reposition_prologue_and_epilogue_notes(), reset_debug_uses_in_loop(), rtl_account_profile_record(), rtl_block_empty_p(), rtl_dump_bb_for_graph(), rtl_split_block_before_cond_jump(), rtl_verify_bb_pointers(), split_live_ranges_for_shrink_wrap(), try_shrink_wrapping(), update_equiv_regs_prescan(), and update_inc_notes().

◆ FOR_BB_INSNS_REVERSE

◆ FOR_BB_INSNS_REVERSE_SAFE

#define FOR_BB_INSNS_REVERSE_SAFE ( BB,
INSN,
CURR )
Value:
for ((INSN) = BB_END (BB),(CURR) = (INSN) ? PREV_INSN ((INSN)) : NULL; \
(INSN) && (INSN) != PREV_INSN (BB_HEAD (BB)); \
(INSN) = (CURR), (CURR) = (INSN) ? PREV_INSN ((INSN)) : NULL)
#define NULL
Definition system.h:50

Referenced by delete_unmarked_insns(), merge_in_block(), prepare_shrink_wrap(), prescan_insns_for_dce(), process_bb_lives(), and reset_unmarked_insns_debug_uses().

◆ FOR_BB_INSNS_SAFE

#define FOR_BB_INSNS_SAFE ( BB,
INSN,
CURR )
Value:
for ((INSN) = BB_HEAD (BB), (CURR) = (INSN) ? NEXT_INSN ((INSN)) : NULL; \
(INSN) && (INSN) != NEXT_INSN (BB_END (BB)); \
(INSN) = (CURR), (CURR) = (INSN) ? NEXT_INSN ((INSN)) : NULL)
For iterating over insns in basic block when we might remove the
current insn.   

Referenced by apply_opt_in_copies(), delete_vta_debug_insns(), lra_coalesce(), lra_final_code_change(), spill_pseudos(), and vt_initialize().

◆ FOR_EACH_BB_FN

#define FOR_EACH_BB_FN ( BB,
FN )
Value:
FOR_BB_BETWEEN (BB, (FN)->cfg->x_entry_block_ptr->next_bb, (FN)->cfg->x_exit_block_ptr, next_bb)
#define FOR_BB_BETWEEN(BB, FROM, TO, DIR)
Definition basic-block.h:209

Referenced by add_noreturn_fake_exit_edges(), add_ranges_and_copies(), add_scope_conflicts(), adjust_cfg_counts(), adjust_simduid_builtins(), autofdo::afdo_annotate_cfg(), autofdo::afdo_calculate_branch_prob(), autofdo::afdo_propagate_edge(), autofdo::afdo_vpt_for_early_inline(), alloc_mem(), allocate_initial_values(), analyze_function(), analyze_memory_references(), assign_discriminators(), assign_spill_hard_regs(), associate_equivalences_with_edges(), branch_prob(), break_superblocks(), brief_dump_cfg(), build_store_vectors(), calculate_bb_reg_pressure(), calculate_dominance_info(), calculate_elim_costs_all_insns(), calculate_equiv_gains(), calculate_gen_cands(), calculate_global_remat_bb_data(), calculate_live_on_exit(), calculate_livein_cands(), calculate_local_reg_remat_bb_data(), calculate_loop_reg_pressure(), can_strub_internally_p(), ccp_initialize(), check_all_va_list_escapes(), check_rtl(), clean_up_after_unswitching(), cleanup_dead_labels(), clear_unused_block_pointer(), coalesce_partitions(), collect_dfa_stats(), combine_and_move_insns(), combine_instructions(), combine_stack_adjustments(), compact_blocks(), compute_alignments(), compute_antic(), compute_bb_for_insn(), compute_bb_predicates(), compute_branch_probabilities(), compute_code_hoist_vbeinout(), compute_cprop_data(), compute_dependence_clique(), compute_dominance_frontiers(), compute_function_frequency(), compute_hash_table(), compute_hash_table_work(), compute_hash_table_work(), compute_insert_delete(), compute_ld_motion_mems(), compute_nearerout(), compute_points_to_sets(), compute_pre_data(), compute_regs_asm_clobbered(), compute_rev_insert_delete(), compute_store_table(), compute_transaction_bits(), copy_cfg_body(), coverage_compute_cfg_checksum(), create_log_links(), cse_condition_code_reg(), debug_dominance_info(), debug_seed_ranger(), decompose_multiword_subregs(), decrease_live_ranges_number(), delete_dead_jumptables(), delete_noop_moves(), delete_vta_debug_insns(), determine_unlikely_bbs(), df_compact_blocks(), df_insn_rescan_all(), df_scan_blocks(), df_scan_start_dump(), df_update_entry_exit_and_calls(), df_word_lr_alloc(), discover_loops(), discover_nonconstant_array_refs(), disqualify_problematic_components(), do_remat(), dot_dominance_tree(), draw_cfg_edges(), dse_step5(), gimple_ranger::dump(), gori_map::dump(), ssa_block_ranges::dump(), dump_candidates_and_remat_bb_data(), dump_cfg_stats(), dump_dataflow_sets(), dump_enumerated_decls(), dump_function_to_file(), dump_live_info(), duplicate_computed_gotos(), eliminate_unnecessary_stmts(), eliminate_useless_phis(), emit_common_heads_for_components(), emit_common_tails_for_components(), emit_moves(), estimate_bb_frequencies(), estimate_num_insns_fn(), pass_walloca::execute(), execute_early_expand_coro_ifns(), execute_fixup_cfg(), execute_omp_device_lower(), execute_split_functions(), execute_update_addresses_taken(), expand_ifn_va_arg(), expand_ifn_va_arg_1(), expand_omp_target(), expand_omp_taskreg(), expand_vector_operations(), expensive_function_p(), fill_always_executed_in(), find_costs_and_classes(), find_explicit_erroneous_behavior(), find_gang_private_vars(), find_implicit_erroneous_behavior(), find_implicit_sets(), find_many_sub_basic_blocks(), find_moveable_pseudos(), find_necessary_statements(), find_obviously_necessary_stmts(), find_partition_fixes(), find_rarely_executed_basic_blocks_and_crossing_edges(), find_removable_extensions(), find_replaceable_exprs(), find_same_succ(), find_split_points(), find_unreachable_blocks(), find_uses_to_rename(), finish_eh_generation(), finish_remat_bb_data(), fix_crossing_conditional_branches(), fix_crossing_unconditional_branches(), fix_loop_structure(), fix_up_fall_thru_edges(), fixup_abnormal_edges(), fixup_partitions(), ipa_icf::sem_item_optimizer::fixup_points_to_sets(), fixup_reorder_chain(), flow_loops_cfg_dump(), force_one_exit_fallthru(), form_loop_tree(), free_all_edge_infos(), free_resource_info(), gather_scalar_reductions(), get_all_stmt_may_generate_copy(), get_loop_body(), gimple_find_values_to_profile(), gimple_lower_bitint(), gimple_value_profile_transformations(), gimple_verify_flow_info(), group_case_labels(), gsi_commit_edge_inserts(), has_nonexceptional_receiver(), has_nonexceptional_receiver(), hoist_code(), if_convert(), ipa_icf::sem_function::init(), init_copy_prop(), init_dont_simulate_again(), init_elimination(), init_resource_info(), init_subregs_of_mode(), init_var_map(), initialize_uninitialized_regs(), inline_forbidden_p(), insert_backedge_copies(), insert_prologue_epilogue_for_components(), insert_section_boundary_note(), instrument_memory_accesses(), ipa_profile_generate_summary(), ipa_pta_execute(), ipa_simd_modify_function_body(), ipa_tm_scan_calls_clone(), ira(), ira_emit(), is_inconsistent(), local_cprop_pass(), lower_emutls_function_body(), lra_coalesce(), lra_create_live_ranges_1(), lra_final_code_change(), lra_inheritance(), make_edges(), make_forwarders_with_degenerate_phis(), make_more_copies(), mark_all_labels(), mark_elimination(), mark_loop_exit_edges(), mark_reachable_handlers(), ipa_param_body_adjustments::modify_cfun_body(), move_sese_region_to_fn(), note_simd_array_uses(), object_sizes_execute(), ok_for_auto_simd_clone(), one_store_motion_pass(), optimize_inline_calls(), optimize_omp_library_calls(), optimize_va_list_gpr_fpr_size(), predict_loops(), prescan_insns_for_dce(), print_loop(), prune_expressions(), purge_all_dead_edges(), cgraph_edge::rebuild_edges(), cgraph_edge::rebuild_references(), record_effective_endpoints(), record_loop_exits(), regrename_analyze(), regstat_compute_calls_crossed(), regstat_compute_ri(), reload(), reload_cse_regs_1(), remove_indirect_clobbers(), remove_inheritance_pseudos(), remove_scratches(), remove_scratches(), remove_unused_locals(), reorder_basic_blocks_simple(), reorder_loops(), replace_loop_annotate(), reset_cluster_vectors(), rewrite_trees(), scan_function(), sese_build_liveouts(), set_bb_indices(), set_edge_can_fallthru_flag(), single_pred_before_succ_order(), spill_pseudos(), split_live_ranges_for_shrink_wrap(), spread_components(), sra_modify_function_body(), strip_predict_hints(), strub_from_body_p(), tail_duplicate(), back_threader::thread_blocks(), thread_prologue_and_epilogue_insns(), transform_statements(), tree_bb_level_predictions(), tree_estimate_probability(), tree_profiling(), tree_ssa_lim_finalize(), try_optimize_cfg(), try_shrink_wrapping(), fwd_jt_path_registry::update_cfg(), update_crossing_jump_flags(), update_equiv_regs(), update_equiv_regs_prescan(), update_inc_notes(), update_ssa(), verify_dominators(), verify_gimple_in_cfg(), verify_histograms(), verify_hot_cold_block_grouping(), verify_loop_closed_ssa(), verify_loop_structure(), verify_marked_backedges(), verify_no_unreachable_blocks(), cgraph_node::verify_node(), verify_non_ssa_vars(), verify_ssa(), verify_ssaname_freelists(), vt_emit_notes(), vt_finalize(), vt_find_locations(), vt_initialize(), warn_uninitialized_vars(), and scc_copy_prop::~scc_copy_prop().

◆ FOR_EACH_BB_REVERSE_FN

◆ FOR_EACH_EDGE

#define FOR_EACH_EDGE ( EDGE,
ITER,
EDGE_VEC )
Value:
for ((ITER) = ei_start ((EDGE_VEC)); \
ei_cond ((ITER), &(EDGE)); \
ei_next (&(ITER)))
#define ei_start(iter)
Definition basic-block.h:378
This macro serves as a convenient way to iterate each edge in a
  vector of predecessor or successor edges.  It must not be used when
  an element might be removed during the traversal, otherwise
  elements will be missed.  Instead, use a for-loop like that shown
  in the following pseudo-code:

  FOR (ei = ei_start (bb->succs); (e = ei_safe_edge (ei)); )
    {
       IF (e != taken_edge)
         remove_edge (e);
       ELSE
         ei_next (&ei);
    }

Referenced by abnormal_edge_after_stmt_p(), add_bb_to_cluster(), add_bb_to_loop(), add_clobbers_to_eh_landing_pad(), add_exit_phi(), add_forwarder_blocks(), add_loop(), add_phi_args_after_copy_bb(), add_phi_args_after_copy_edge(), add_ranges_and_copies(), add_scope_conflicts_1(), adjust_cfg_counts(), autofdo::afdo_calculate_branch_prob(), autofdo::afdo_propagate_circuit(), autofdo::afdo_propagate_edge(), autofdo::afdo_set_bb_count(), all_preds_critical_p(), alloc_aux_for_edges(), analyze_function_body(), ranger_cache::apply_inferred_ranges(), apply_return_prediction(), assign_discriminators(), bb_has_well_behaved_predecessors(), bb_loop_header_p(), dom_walker::bb_reachable(), bb_to_key(), bb_with_exit_edge_p(), eliminate_dom_walker::before_dom_children(), find_comparison_dom_walker::before_dom_children(), nontrapping_dom_walker::before_dom_children(), begin_any_block(), block_jumps_and_fallthru(), branch_prob(), branch_removable_p(), tree_switch_conversion::switch_conversion::build_arrays(), build_region(), bypass_block(), calculate_live_on_exit(), can_copy_bbs_p(), can_delete_call(), can_dup_for_shrink_wrapping(), can_fallthru(), can_get_prologue(), can_track_predicate_on_edge(), cfun_returns(), tree_switch_conversion::switch_conversion::check_all_empty_except_final(), check_bb_profile(), clean_up_after_unswitching(), cleanup_call_ctrl_altering_flag(), cleanup_control_flow_pre(), cleanup_empty_eh(), cleanup_empty_eh_merge_phis(), cleanup_tree_cfg_noloop(), clear_aux_for_edges(), clobber_only_eh_bb_p(), coalesce_cost_edge(), coalesce_partitions(), tree_switch_conversion::switch_conversion::collect(), combine_blocks(), combine_predictions_for_bb(), commit_edge_insertions(), compute_alignments(), compute_antic(), compute_antic_aux(), compute_antinout_edge(), compute_available(), compute_bb_predicates(), compute_branch_probabilities(), compute_control_dep_chain(), compute_dominance_frontiers(), compute_laterin(), compute_live_loop_exits(), compute_live_vars_1(), compute_nearerout(), compute_optimized_partition_bases(), compute_outgoing_frequencies(), compute_partial_antic_aux(), compute_path_counts(), cond_exec_find_if_block(), connect_traces(), consider_split(), construct_exit_block(), control_dependences::control_dependences(), copy_bbs(), copy_cfg_body(), copy_edges_for_bb(), copy_phis_for_bb(), correct_negative_edge_counts(), could_fall_through(), coverage_compute_cfg_checksum(), cprop_into_successor_phis(), cprop_jump(), create_block_for_threading(), create_edge_list(), create_fixup_graph(), create_loop_tree_node_allocnos(), create_loop_tree_nodes(), create_preheader(), create_rdg_cd_edges(), cse_cc_succs(), dce_process_block(), deps_ok_for_redirect_from_bb_to_bb(), determine_bb_domination_status(), determine_dominators_for_sons(), determine_unlikely_bbs(), df_print_bb_index(), df_worklist_propagate_backward(), df_worklist_propagate_forward(), dfs_broadcast_reachable_1(), dfs_enumerate_from(), dfs_find_deadend(), discover_iteration_bound_by_body_walk(), discover_loop(), disqualify_problematic_components(), do_hoist_insertion(), do_pre_partial_partial_insertion(), do_pre_regular_insertion(), do_rpo_vn_1(), dominated_by_p_w_unex(), draw_cfg_edges(), draw_cfg_node_succ_edges(), dump_basic_block_info(), gimple_ranger::dump_bb(), dump_bb_info(), dump_gimple_cond(), dump_prediction(), duplicate_block(), duplicate_loop_body_to_header_edge(), back_jt_path_registry::duplicate_thread_path(), edge_before_returns_twice_call(), eliminate_partially_redundant_load(), emit_case_dispatch_table(), emit_common_heads_for_components(), emit_common_tails_for_components(), emit_moves(), end_any_block(), entered_from_non_parent_p(), estimate_bb_frequencies(), evaluate_bbs(), crc_symbolic_execution::execute_bb_gimple_statements(), execute_early_expand_coro_ifns(), execute_ranger_vrp(), tree_switch_conversion::switch_conversion::exp_index_transform(), expand_asm_stmt(), expand_call_tm(), expand_complex_libcall(), expand_gimple_basic_block(), expand_omp_sections(), expand_phi_nodes(), expand_transaction(), ext_dce_rd_transfer_n(), fast_dce(), fill_always_executed_in_1(), ranger_cache::fill_block_cache(), find_always_executed_bbs(), find_bbs_reachable_by_hot_paths(), find_best_predecessor(), find_best_successor(), find_control_dep_blocks(), find_edge(), find_exits(), find_interesting_uses(), find_jump_block(), find_obviously_necessary_stmts(), back_threader::find_paths_to_names(), find_rarely_executed_basic_blocks_and_crossing_edges(), find_same_succ_bb(), find_simple_exit(), find_tail_calls(), find_traces(), find_traces_1_round(), find_unreachable_blocks(), find_unswitching_predicates_for_bb(), find_uses_to_rename_bb(), finish_eh_generation(), fix_bb_placement(), fix_bb_placements(), fixup_abnormal_edges(), fixup_new_cold_bb(), fixup_partition_crossing(), fixup_reorder_chain(), flow_find_head_matching_sequence(), flow_loop_nodes_find(), flow_loops_cfg_dump(), flow_loops_find(), fold_marked_statements(), force_edge_cold(), force_one_exit_fallthru(), form_subloop(), free_all_edge_infos(), free_cfg(), get_abnormal_succ_dispatcher(), get_exec_counts(), get_false_edge_from_guard_bb(), virtual_operand_live::get_live_in(), get_live_on_other_edges(), get_loop_body_in_bfs_order(), get_loop_exit_edges(), get_loop_hot_path(), get_loop_latch_edges(), get_outgoing_edge_probs(), get_tm_region_blocks(), get_true_edge_from_guard_bb(), gimple_find_sub_bbs(), gimple_ic(), gimple_make_forwarder_block(), gimple_ranger::gimple_ranger(), gimple_split_block(), gimple_verify_flow_info(), gsi_commit_edge_inserts(), gsi_insert_finally_seq_after_call(), guards_builtin_unreachable(), has_abnormal_call_or_eh_pred_edge_p(), has_abnormal_or_eh_outgoing_edge_p(), has_nonexceptional_receiver(), has_nonexceptional_receiver(), has_preds_from_loop(), have_eh_succ_edges(), if_convertible_bb_p(), if_convertible_loop_p(), ifcvt_split_critical_edges(), imm_dom_path_with_freeing_call(), independent_of_stmt_p(), predicate::init_from_control_deps(), insert(), insert_into_preds_of_block(), insert_phi_nodes_for(), insert_prologue_epilogue_for_components(), insert_store(), insert_updated_phi_nodes_for(), instrument_edges(), instrument_func_exit(), inverted_rev_post_order_compute(), ipa_tm_propagate_irr(), ipa_tm_scan_irr_blocks(), ipa_tm_transform_calls(), ira(), ira_emit(), ira_loop_edge_freq(), ira_loop_tree_body_rev_postorder(), is_cond_scalar_reduction(), is_edge_inconsistent(), iterate_fix_dominators(), live_edge_for_reg(), loe_visit_block(), loop_count_in(), loop_exits_from_bb_p(), loop_exits_to_bb_p(), loop_preheader_edge(), lower_eh_dispatch(), lower_resx(), lra_process_new_insns(), make_edges(), make_forwarder_block(), malloc_candidate_p(), mark_basic_block_deleted(), mark_irreducible_loops(), mark_loop_exit_edges(), mark_reachable_blocks(), fwd_jt_path_registry::mark_threaded_blocks(), maybe_lower_iteration_bound(), maybe_move_debug_stmts_to_successors(), maybe_optimize_range_tests(), maybe_register_def(), merge_blocks(), merge_loop_tree(), move_block_to_fn(), move_sese_region_to_fn(), oacc_loop_discover_walk(), omp_sese_find_par(), optimize_clobbers(), optimize_unreachable(), outgoing_edges_match(), output_cfg(), peep2_attempt(), phi_result_unknown_predicate(), phiprop_insert_phi(), place_prologue_for_one_component(), pre_expr_reaches_here_p_work(), pred_blocks_visited_p(), predict_extra_loop_exits(), predict_iv_comparison(), predict_loops(), predict_paths_for_bb(), predict_paths_leading_to_edge(), prepare_block_for_update_1(), print_loop_title(), print_pred_bbs(), print_succ_bbs(), process_bb(), process_incoming_edges(), profile_record_check_consistency(), ranger_cache::propagate_cache(), propagate_freq(), substitute_and_fold_engine::propagate_into_phi_args(), propagate_unlikely_bbs_forward(), dom_walker::propagate_unreachable_to_edges(), ranger_cache::propagate_updated_value(), prune_bbs_to_update_dominators(), prune_expressions(), prune_unused_phi_nodes(), purge_dead_edges(), ranger_cache::range_from_dom(), reachable_at_most_once(), read_profile_edge_counts(), rebuild_frequencies(), recompute_dominator(), record_edge_info(), record_loop_exits(), redirect_eh_edge_1(), regrename_analyze(), reload_cse_regs_1(), remove_bb_from_loops(), remove_dead_stmt(), remove_edge_and_dominated_blocks(), remove_exit_barrier(), remove_fallthru_edge(), remove_forwarder_block(), remove_path(), remove_unused_locals(), rename_variables_in_bb(), reorder_loops(), replace_block_by(), reposition_prologue_and_epilogue_notes(), tree_switch_conversion::switch_decision_tree::reset_out_edges_aux(), ranger_cache::resolve_dom(), rev_post_order_and_mark_dfs_back_seme(), rewrite_add_phi_arguments(), rewrite_blocks(), rewrite_update_phi_arguments(), rotate_loop(), rtl_split_block(), rtl_verify_edges(), sanitize_hot_paths(), scan_loop(), set_all_edges_as_executable(), simplify_using_ranges::set_and_propagate_unexecutable(), set_cond_stmt_execution_predicate(), set_edge_can_fallthru_flag(), set_edge_probability_and_rescale_others(), set_even_probabilities(), set_switch_stmt_execution_predicate(), should_duplicate_loop_header_p(), should_hoist_expr_to_dom(), simplify_loop_version(), simplify_using_ranges::simplify_switch_using_ranges(), ssa_propagation_engine::simulate_block(), ssa_propagation_engine::simulate_stmt(), single_non_eh_succ(), single_pred_edge_ignoring_loop_edges(), sink_clobbers(), sink_code_in_bb(), slpeel_tree_duplicate_loop_to_edge_cfg(), split_block_1(), split_critical_edges(), split_edge(), split_function(), split_live_ranges_for_shrink_wrap(), spread_components(), sra_modify_call_arg(), ssa_prop_init(), ssa_propagation_engine::ssa_propagate(), stmt_can_terminate_bb_p(), suitable_cond_bb(), sum_edge_counts(), jump_threader::thread_across_edge(), fwd_jt_path_registry::thread_block_1(), thread_prologue_and_epilogue_insns(), fwd_jt_path_registry::thread_through_loop_header(), tm_memopt_compute_antic(), tm_memopt_compute_available(), tm_region_init(), tree_bb_level_predictions(), tree_estimate_probability_bb(), tree_forwarder_block_p(), tree_optimize_tail_calls_1(), tree_predict_by_opcode(), try_crossjump_to_edge(), try_head_merge_bb(), try_optimize_cfg(), try_shrink_wrapping(), uncprop_into_successor_phis(), update_bb_reg_pressure(), fwd_jt_path_registry::update_cfg(), update_crossing_jump_flags(), update_destination_phis(), update_ebb_live_info(), update_loop_exit_probability_scale_dom_bbs(), update_profile(), update_profile_for_new_sub_basic_block(), update_ssa_across_abnormal_edges(), vect_schedule_scc(), verify_edge_list(), verify_eh_dispatch_edge(), verify_eh_edges(), verify_flow_info(), verify_gimple_in_cfg(), verify_live_on_entry(), verify_loop_structure(), verify_marked_backedges(), verify_non_ssa_vars(), verify_ssa(), verify_vssa(), visit_bb(), vn_phi_compute_hash(), vn_phi_insert(), vn_phi_lookup(), vt_find_locations(), dom_walker::walk(), warn_uninit_phi_uses(), warn_uninitialized_vars(), and word_dce_process_block().

◆ GCOV_COMPUTE_SCALE

#define GCOV_COMPUTE_SCALE ( num,
den )
Value:
((den) ? RDIV ((num) * REG_BR_PROB_BASE, (den)) : REG_BR_PROB_BASE)
#define RDIV(X, Y)
Definition profile-count.h:75
#define REG_BR_PROB_BASE
Definition profile-count.h:73
Compute a scale factor (or probability) suitable for scaling of
gcov_type values via apply_probability() and apply_scale().   

Referenced by ipa_profile_generate_summary().

◆ INDEX_EDGE

#define INDEX_EDGE ( el,
index )
Value:
((el)->index_to_edge[(index)])
INDEX_EDGE returns a pointer to the edge.   

Referenced by branch_prob(), compute_laterin(), compute_nearerout(), find_spanning_tree(), one_store_motion_pass(), and pre_edge_insert().

◆ INDEX_EDGE_PRED_BB

#define INDEX_EDGE_PRED_BB ( el,
index )
Value:
((el)->index_to_edge[(index)]->src)
INDEX_EDGE_PRED_BB and INDEX_EDGE_SUCC_BB return a pointer to the basic
block which is either the pred or succ end of the indexed edge.   

Referenced by compute_earliest(), compute_farthest(), compute_rev_insert_delete(), find_edge_index(), pre_edge_insert(), print_edge_list(), and verify_edge_list().

◆ INDEX_EDGE_SUCC_BB

#define INDEX_EDGE_SUCC_BB ( el,
index )

◆ label_to_block_map_for_fn

#define label_to_block_map_for_fn ( FN)

◆ last_basic_block_for_fn

#define last_basic_block_for_fn ( FN)
Value:
((FN)->cfg->x_last_basic_block)

Referenced by infer_range_manager::add_range(), add_scope_conflicts(), alloc_gcse_mem(), alloc_mem(), analyze_function_body(), apply_opt_in_copies(), associate_equivalences_with_edges(), loop_distribution::bb_top_order_init(), break_superblocks(), build_store_vectors(), gori_map::calculate_gori(), cleanup_control_flow_pre(), cleanup_dead_labels(), cleanup_tree_cfg_noloop(), compact_blocks(), compute_antic(), compute_antinout_edge(), compute_available(), compute_branch_probabilities(), compute_code_hoist_vbeinout(), compute_idf(), compute_insert_delete(), compute_laterin(), compute_live_vars(), compute_local_properties(), compute_local_properties(), compute_nearerout(), compute_pre_data(), compute_rev_insert_delete(), control_dependences::control_dependences(), copy_bb(), copy_cfg_body(), copy_phi_node_args(), create_basic_block_structure(), create_bb(), create_loop_tree_nodes(), create_remat_bb_data(), cse_main(), decompose_multiword_subregs(), determine_unlikely_bbs(), df_compact_blocks(), df_grow_bb_info(), df_live_verify_solution_start(), df_lr_verify_solution_start(), df_md_local_compute(), df_mir_verify_solution_start(), df_worklist_dataflow(), df_worklist_dataflow_doublequeue(), do_rpo_vn_1(), dom_oracle::dom_oracle(), dom_ranger::dom_ranger(), draw_cfg_nodes_no_loops(), dse_step0(), dse_step3(), equiv_oracle::equiv_oracle(), execute_split_functions(), expand_call_inline(), ext_dce_init(), fill_always_executed_in(), ranger_cache::fill_block_cache(), find_implicit_sets(), find_many_sub_basic_blocks(), find_moveable_pseudos(), find_necessary_statements(), fix_bb_placements(), fold_marked_statements(), gcse_after_reload_main(), get_bb_regions_instrumented(), gimple_dump_cfg(), gimple_duplicate_loop_body_to_header_edge(), gimple_flow_call_edges_add(), gori_compute::gori_compute(), gori_map::gori_map(), sbr_vector::grow(), hoist_code(), infer_range_manager::infer_range_manager(), virtual_operand_live::init(), init_empty_tree_cfg_for_function(), init_reassoc(), init_resource_info(), init_worklist(), initiate_live_solver(), input_cfg(), insert(), inverted_rev_post_order_compute(), ipa_analyze_node(), ipa_merge_profiles(), ipa_sra_summarize_function(), ipcp_transform_function(), ira(), ira_emit(), equiv_oracle::limit_check(), live_worklist(), loop_invariant_motion_in_fun(), lra(), make_edges(), mark_dfs_back_edges(), mark_irreducible_loops(), new_tree_live_info(), oacc_do_neutering(), one_code_hoisting_pass(), one_cprop_pass(), one_pre_gcse_pass(), opt_info_start_duplication(), output_cfg(), function_reader::parse_block(), perform_tree_ssa_dce(), post_order_compute(), pre_edge_lcm(), pre_edge_lcm_avs(), pre_edge_rev_lcm(), pre_expr_reaches_here_p(), prepare_def_site_for(), prune_insertions_deletions(), ranger_cache::ranger_cache(), reachable_at_most_once(), record_edge_info(), regrename_analyze(), reload(), remove_dead_stmt(), remove_path(), remove_reachable_equiv_notes(), remove_unnecessary_regions(), reorder_basic_blocks_software_trace_cache(), rev_post_order_and_mark_dfs_back_seme(), rtl_create_basic_block(), rtl_flow_call_edges_add(), sbr_vector::sbr_vector(), block_range_cache::set_bb_range(), dom_oracle::set_one_relation(), should_hoist_expr_to_dom(), single_pred_before_succ_order(), sort_sibling_loops(), split_all_insns(), ssa_prop_init(), tail_duplicate(), thread_prologue_and_epilogue_insns(), tm_region_init(), transform_statements(), tree_dce_init(), tree_lower_complex(), update_dominators_in_loop(), update_list::update_list(), update_ssa(), verify_flow_info(), verify_loop_structure(), verify_ssa(), vt_find_locations(), and dom_walker::walk().

◆ n_basic_blocks_for_fn

#define n_basic_blocks_for_fn ( FN)
Value:
((FN)->cfg->x_n_basic_blocks)

Referenced by add_loop(), alloc_cluster_vectors(), analyze_function_body(), analyze_memory_references(), associate_equivalences_with_edges(), loop_distribution::bb_top_order_init(), branch_prob(), build_gimple_cfg(), calculate_dominance_info(), cleanup_control_flow_pre(), compact_blocks(), compute_antic(), compute_antinout_edge(), compute_avail(), compute_available(), compute_laterin(), compute_live_loop_exits(), compute_nearerout(), coverage_compute_cfg_checksum(), create_bb(), create_fixup_graph(), dbr_schedule(), df_analyze(), df_compact_blocks(), df_worklist_dataflow_doublequeue(), do_reassoc(), do_rpo_vn_1(), draw_cfg_nodes_no_loops(), dump_cfg_stats(), dump_flow_info(), dump_function_to_file(), entry_of_function(), execute_over_cond_phis(), execute_split_paths(), expunge_block(), ext_dce_execute(), find_conditions(), find_path(), find_unreachable_blocks(), flow_loops_find(), fold_marked_statements(), gcse_or_cprop_is_too_expensive(), generate_setjmp_warnings(), get_loop_body(), gimple_dump_cfg(), gimple_find_sub_bbs(), gimple_flow_call_edges_add(), has_nonexceptional_receiver(), has_nonexceptional_receiver(), init_alias_analysis(), init_empty_tree_cfg_for_function(), uninit_analysis::init_from_phi_def(), init_loops_structure(), init_reassoc(), uninit_analysis::init_use_preds(), init_var_map(), init_worklist(), insert(), inverted_rev_post_order_compute(), ipa_merge_profiles(), ira_build(), lra_create_live_ranges_1(), make_edges(), make_new_block(), mark_dfs_back_edges(), merge_loop_tree(), one_code_hoisting_pass(), one_cprop_pass(), one_pre_gcse_pass(), one_store_motion_pass(), optimize_inline_calls(), function_reader::parse_block(), post_order_compute(), pre_and_rev_post_order_compute(), pre_and_rev_post_order_compute_fn(), prepare_block_for_update(), print_edge_list(), regrename_analyze(), remove_dead_stmt(), remove_path(), remove_reachable_equiv_notes(), reorder_basic_blocks(), reorder_basic_blocks_simple(), reorder_basic_blocks_software_trace_cache(), returning_call_p(), rev_post_order_and_mark_dfs_back_seme(), rt_bb_visited::rt_bb_visited(), rtl_create_basic_block(), rtl_flow_call_edges_add(), rtl_verify_bb_layout(), single_pred_before_succ_order(), sort_sibling_loops(), split_live_ranges_for_shrink_wrap(), spread_components(), ssa_prop_init(), tail_duplicate(), try_forward_edges(), try_optimize_cfg(), try_shrink_wrapping(), unroll_jam_possible_p(), fwd_jt_path_registry::update_cfg(), variable_tracking_main_1(), vect_slp_function(), verify_loop_structure(), vt_find_locations(), vt_stack_adjustments(), and dom_walker::walk().

◆ n_edges_for_fn

◆ NUM_EDGES

◆ NUM_FIXED_BLOCKS

◆ profile_status_for_fn

◆ SET_BASIC_BLOCK_FOR_FN

Enumeration Type Documentation

◆ cfg_bb_flags

Enumerator
LAST_CFG_BB_FLAG 
Flags on basic blocks and edges.
   Copyright (C) 2012-2025 Free Software Foundation, Inc.

This file is part of GCC.

GCC is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free
Software Foundation; either version 3, or (at your option) any later
version.

GCC is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
for more details.

You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING3.  If not see
<http://www.gnu.org/licenses/>.   
This file defines flags that may appear on basic blocks or on
edges.  Source files define DEF_BASIC_BLOCK_FLAG or DEF_EDGE_FLAG
appropriately before including this file.   
Masks for basic_block.flags.

The format of this file is: DEF_BASIC_BLOCK_FLAG(NAME, IDX).
NAME is the name of the basic block flag.  A flag BB_#NAME will be
created and the name is used in dump_edge_info.
IDX is a sequence number that is used to determine the value
of the flag, which is 1 << IDX).

BB_HOT_PARTITION and BB_COLD_PARTITION should be preserved throughout
the compilation, so they are never cleared.

All other flags may be cleared by clear_bb_flags().  It is generally
a bad idea to rely on any flags being up-to-date.   
Only set on blocks that have just been created by create_bb.   
Set by find_unreachable_blocks.  Do not rely on this being set in any
pass.   
Set for blocks in an irreducible loop by loop analysis.   
Set on blocks that may actually not be single-entry single-exit block.   
Set on basic blocks that the scheduler should not touch.  This is used
by SMS to prevent other schedulers from messing with the loop schedule.   
Set on blocks that should be put in a hot section.   
Set on blocks that should be put in a cold section.   
Set on block that was duplicated.   
Set if the label at the top of this block is the target of a non-local goto.   
Set on blocks that are in RTL format.   
Set on blocks that are forwarder blocks.
Only used in cfgcleanup.cc.   
Set on blocks that cannot be threaded through.
Only used for jump threading.   
Set on blocks that were modified in some way.  This bit is set in
df_set_bb_dirty, but not cleared by df_analyze, so it can be used
to test whether a block has been modified prior to a df_analyze call.   
A general visited flag for passes to use.   
Set on blocks that are in a transaction.  This is calculated on
demand, and is available after calling compute_transaction_bits().   

◆ cfg_edge_flags

Enumerator
LAST_CFG_EDGE_FLAG 
Flags on basic blocks and edges.
   Copyright (C) 2012-2025 Free Software Foundation, Inc.

This file is part of GCC.

GCC is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free
Software Foundation; either version 3, or (at your option) any later
version.

GCC is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
for more details.

You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING3.  If not see
<http://www.gnu.org/licenses/>.   
This file defines flags that may appear on basic blocks or on
edges.  Source files define DEF_BASIC_BLOCK_FLAG or DEF_EDGE_FLAG
appropriately before including this file.   
Masks for edge.flags.

The format of this file is: DEF_EDGE_FLAG(NAME, IDX, STRING).
NAME is the name of the edge flag.  A flag EDGE_#NAME will be
created and the name is used in dump_edge_info.
IDX is a sequence number that is used to determine the value
of the flag, which is 1 << IDX).   
'Straight line' flow.  In GIMPLE and in cfglayout mode, all normal
edges are fallthru edges.  In cfgrtl mode, this flag really means
that control flow falls through to the next basic block in the line.   
Strange flow, like a computed jump or exception handling.  Usually
this means that the edge cannot be split.   
Edge out of a basic block that ends with a CALL_INSN with abnormal
exit, like an exception or a non-local goto.
ABNORMAL_CALL edges also have ABNORMAL set.
This flag is only used for the RTL CFG.   
Exception edge.  Exception handling edges represent possible control
transfers from a trapping instruction to an exception handler.
EH edges also have ABNORMAL set for the RTL CFG.   
Never merge blocks via this edge.  This is used for exception handling,
to prevent merging away edges to the post-landing-pad basic block.
This flag is only used for the RTL CFG.   
Not a real edge.  This is used to connect parts of the CFG that do
not halt, such as infinite loops and noreturn functions, to the
EXIT_BLOCK, so that traversing of the reverse CFG is possible.   
A back edge, marked in a depth-first search of the CFG.  Back edges
are hints that this edge may be part of a loop in the CFG.   
Edge in a part of the CFG that is an irreducible loop.   
Edge taken when controlling predicate is nonzero.
This is only used for the GIMPLE CFG.   
Edge taken when controlling predicate is zero.
This is only used for the GIMPLE CFG.   
Edge is executable.  This is only used in GIMPLE SSA-CCP and VRP.
This is only used for the GIMPLE CFG.   
Edge crosses between hot and cold sections, when we do partitioning.
This flag is only used for the RTL CFG.   
Edge from a sibcall CALL_INSN to exit.
SIBCALL edges also have ABNORMAL set.
This flag is only used for the RTL CFG.   
Candidate for straight line flow.  Only used in bb-reorder.cc.
This flag is only used for the RTL CFG.   
Exit of a loop.  This is only used in ifcvt.cc.
This flag is only used for the RTL CFG.   
Uninstrumented edge out of a GIMPLE_TRANSACTION statement.   
Abort (over) edge out of a GIMPLE_TRANSACTION statement.   
An edge we should ignore.  It should be entirely local to
passes.  ie, it is never set on any edge upon the completion
of any pass.   

Function Documentation

◆ apply_probability()

gcov_type apply_probability ( gcov_type freq,
int prob )
inline
Apply probability PROB on frequency or count FREQ.   

References apply_scale(), and check_probability().

◆ apply_scale()

gcov_type apply_scale ( gcov_type freq,
gcov_type scale )
inline
Apply scale factor SCALE on frequency or count FREQ. Use this
interface when potentially scaling up, so that SCALE is not
constrained to be < REG_BR_PROB_BASE.   

References RDIV, and REG_BR_PROB_BASE.

Referenced by apply_probability(), asan_clear_shadow(), emit_block_cmp_via_loop(), emit_block_move_via_loop(), emit_block_move_via_oriented_loop(), and get_cond_branch_to_split_loop().

◆ bb_has_abnormal_pred()

◆ bb_has_eh_pred()

bool bb_has_eh_pred ( basic_block bb)
inline
Return true when one of the predecessor edges of BB is marked with EDGE_EH.   

Referenced by cse_extended_basic_block(), df_bb_refs_collect(), df_exit_block_uses_collect(), df_simulate_fixup_sets(), fast_dce(), find_clusters_1(), process_bb_lives(), and process_bb_node_lives().

◆ bb_in_transaction()

bool bb_in_transaction ( basic_block bb)
inline
Return true if BB is in a transaction.   

References basic_block_def::flags.

Referenced by execute_sm(), and gimple_in_transaction().

◆ check_probability()

void check_probability ( int prob)
inline
Check tha probability is sane.   

References gcc_checking_assert, and REG_BR_PROB_BASE.

Referenced by apply_probability(), combine_probabilities(), and inverse_probability().

◆ combine_probabilities()

int combine_probabilities ( int prob1,
int prob2 )
inline
Given PROB1 and PROB2, return PROB1*PROB2/REG_BR_PROB_BASE.
Used to combine BB probabilities.   

References check_probability(), RDIV, and REG_BR_PROB_BASE.

Referenced by remap_edge_params().

◆ ei_cond()

bool ei_cond ( edge_iterator ei,
edge * p )
inline
Return 1 if we should continue to iterate.  Return 0 otherwise.
*Edge P is set to the next edge if we are to continue to iterate
and NULL otherwise.   

References ei_edge(), ei_end_p(), and NULL.

Referenced by _succ_iter_cond(), ipa_icf::sem_function::equals_private(), and ipa_icf::sem_function::init().

◆ ei_container()

◆ ei_edge()

◆ ei_end_p()

bool ei_end_p ( edge_iterator i)
inline
Is the iterator `i' at the end of the sequence?   

References EDGE_COUNT, ei_container(), and i.

Referenced by ei_cond(), ei_safe_edge(), reload_cse_regs_1(), remove_reachable_equiv_notes(), rev_post_order_and_mark_dfs_back_seme(), and verify_sese().

◆ ei_last_1()

edge_iterator ei_last_1 ( vec< edge, va_gc > ** ev)
inline
Return an iterator pointing to the last element of an edge
vector.   

References EDGE_COUNT, and i.

◆ ei_next()

◆ ei_one_before_end_p()

◆ ei_prev()

void ei_prev ( edge_iterator * i)
inline
Move the iterator to the previous element.   

References gcc_checking_assert, and i.

◆ ei_safe_edge()

◆ ei_start_1()

edge_iterator ei_start_1 ( vec< edge, va_gc > ** ev)
inline
Return an iterator pointing to the start of an edge vector.   

References i.

◆ find_fallthru_edge()

◆ has_abnormal_call_or_eh_pred_edge_p()

bool has_abnormal_call_or_eh_pred_edge_p ( basic_block bb)
inline
Return true when one of the predecessor edges of BB is marked with
EDGE_ABNORMAL_CALL or EDGE_EH.   

References FOR_EACH_EDGE, and basic_block_def::preds.

Referenced by process_bb_lives(), process_bb_node_lives(), and ranger_cache::range_from_dom().

◆ has_abnormal_or_eh_outgoing_edge_p()

bool has_abnormal_or_eh_outgoing_edge_p ( basic_block bb)
inline
Return true if BB has at least one abnormal outgoing edge.   

References FOR_EACH_EDGE, and basic_block_def::succs.

Referenced by find_explicit_erroneous_behavior(), find_implicit_erroneous_behavior(), and find_tail_calls().

◆ inverse_probability()

int inverse_probability ( int prob1)
inline
Return inverse probability for PROB.   

References check_probability(), and REG_BR_PROB_BASE.

◆ single_pred()

basic_block single_pred ( const_basic_block bb)
inline
Returns the single predecessor block of basic block BB.  Aborts
if BB does not have exactly one predecessor. 

References single_pred_edge().

Referenced by assume_query::assume_query(), find_comparison_dom_walker::before_dom_children(), tree_switch_conversion::switch_conversion::check_final_bb(), cleanup_tree_cfg_bb(), combine_instructions(), compute_complex_ancestor_jump_func(), cond_exec_find_if_block(), create_call_for_reduction(), create_parallel_loop(), create_phi_for_local_result(), do_while_loop_p(), expand_oacc_for(), expand_omp_for_static_chunk(), expand_omp_for_static_nochunk(), expand_omp_sections(), expand_simple_operations(), force_nonfallthru(), gen_parallel_loop(), get_bb_avail_insn(), ifcombine_ifandif(), ifcombine_replace_cond(), ip_normal_pos(), ipa_analyze_indirect_call_uses(), maybe_optimize_range_tests(), omp_sese_find_par(), phi_result_unknown_predicate(), propagate_threaded_block_debug_into(), prune_bbs_to_update_dominators(), redirect_edge_and_branch_force(), remove_forwarder_block(), remove_forwarder_block_with_phi(), rename_variables_in_bb(), separate_decls_in_region(), set_location_for_edge(), simplify_using_initial_values(), single_pred_before_succ_order(), slpeel_tree_duplicate_loop_to_edge_cfg(), sm_seq_valid_bb(), spaceship_replacement(), split_edge(), transform_statements(), tree_ssa_ifcombine_bb(), tree_transform_and_unroll_loop(), try_optimize_cfg(), try_transform_to_exit_first_loop_alt(), update_profile_after_ifcombine(), update_range_test(), vec_init_loop_exit_info(), vect_analyze_early_break_dependences(), vect_analyze_loop_form(), vect_do_peeling(), vect_loop_vectorized_call(), verify_sese(), versionable_outer_loop_p(), and crc_optimization::xor_calculates_crc().

◆ single_pred_edge()

edge single_pred_edge ( const_basic_block bb)
inline

◆ single_pred_p()

bool single_pred_p ( const_basic_block bb)
inline
Returns true if BB has precisely one predecessor.   

References EDGE_COUNT, and basic_block_def::preds.

Referenced by assume_query::assume_query(), bb_has_well_behaved_predecessors(), find_comparison_dom_walker::before_dom_children(), bound_difference(), branch_removable_p(), bypass_conditional_jumps(), can_track_predicate_on_edge(), cfg_layout_can_merge_blocks_p(), tree_switch_conversion::switch_conversion::check_final_bb(), clean_up_loop_closed_phi(), cleanup_empty_eh_merge_phis(), cleanup_tree_cfg_bb(), tree_switch_conversion::switch_conversion::collect(), combine_instructions(), commit_one_edge_insertion(), compute_complex_ancestor_jump_func(), compute_control_dep_chain_pdom(), cond_exec_find_if_block(), create_empty_if_region_on_edge(), cse_find_path(), destroy_loop(), determine_value_range(), disqualify_problematic_components(), do_hoist_insertion(), do_while_loop_p(), eliminate_temp_copies(), emit_mfence_after_loop(), empty_bb_or_one_feeding_into_p(), execute_sm_if_changed(), expand_omp_for_static_chunk(), expand_omp_sections(), expand_phi_nodes(), extract_true_false_controlled_edges(), final_value_replacement_loop(), find_block_to_duplicate_for_splitting_paths(), find_if_case_1(), find_if_case_2(), find_implicit_sets(), find_return_bb(), find_traces_1_round(), fix_loop_bb_probability(), fixup_reorder_chain(), force_edge_cold(), get_bb_avail_insn(), gimple_can_merge_blocks_p(), gimple_find_edge_insert_loc(), gimple_make_forwarder_block(), uninit_analysis::init_use_preds(), insert(), ip_normal_pos(), ipa_analyze_indirect_call_uses(), maybe_move_debug_stmts_to_successors(), maybe_optimize_guarding_check(), maybe_optimize_range_tests(), maybe_register_def(), minmax_replacement(), noce_find_if_block(), oacc_loop_discover_walk(), optimize_atomic_bit_test_and(), optimize_spaceship(), phi_result_unknown_predicate(), potentially_threadable_block(), dom_ranger::pre_bb(), predict_loops(), propagate_threaded_block_debug_into(), prune_bbs_to_update_dominators(), relation_oracle::query(), ranger_cache::range_from_dom(), fold_using_range::range_of_range_op(), relation_oracle::record(), remove_forwarder_block(), remove_forwarder_block_with_phi(), remove_path(), rename_variables_in_bb(), replace_phi_edge_with_variable(), rtl_can_merge_blocks(), select_best_block(), set_location_for_edge(), should_duplicate_loop_header_p(), simple_control_dep_chain(), simplify_using_initial_conditions(), simplify_using_initial_values(), single_pred_before_succ_order(), single_pred_edge(), sink_clobbers(), sm_seq_valid_bb(), spaceship_replacement(), split_critical_edges(), suitable_cond_bb(), transform_statements(), transform_to_exit_first_loop_alt(), tree_forwarder_block_p(), tree_optimize_tail_calls_1(), tree_ssa_ifcombine_bb(), try_crossjump_to_edge(), try_optimize_cfg(), try_simplify_condjump(), try_transform_to_exit_first_loop_alt(), unsplit_eh(), update_loop_exit_probability_scale_dom_bbs(), update_profile_after_ifcombine(), value_replacement(), vec_init_loop_exit_info(), vect_analyze_early_break_dependences(), vect_do_peeling(), vect_loop_vectorized_call(), vect_set_loop_condition_normal(), vect_transform_loop(), vectorizable_live_operation_1(), verify_sese(), versionable_outer_loop_p(), vt_initialize(), and crc_optimization::xor_calculates_crc().

◆ single_succ()

basic_block single_succ ( const_basic_block bb)
inline
Returns the single successor block of basic block BB.  Aborts
if BB does not have exactly one successor.   

References single_succ_edge().

Referenced by bb_next_bb(), build_and_add_sum(), build_ssa_conflict_graph(), can_move_invariant_reg(), cfg_layout_can_merge_blocks_p(), cleanup_tree_cfg_bb(), tree_switch_conversion::switch_conversion::collect(), compute_alignments(), compute_partial_antic_aux(), cond_exec_find_if_block(), create_empty_loop_on_edge(), dead_or_predicable(), determine_parallel_type(), dse_step1(), dump_oacc_loop_part(), eliminate_tail_call(), eliminate_unnecessary_stmts(), expand_gimple_basic_block(), expand_omp_atomic(), expand_omp_atomic_cas(), expand_omp_atomic_fetch_op(), expand_omp_atomic_load(), expand_omp_atomic_pipeline(), expand_omp_atomic_store(), expand_omp_for_generic(), expand_omp_for_static_chunk(), expand_omp_for_static_nochunk(), expand_omp_sections(), expand_omp_simd(), expand_omp_target(), expand_omp_taskreg(), find_loop_guard(), find_tail_calls(), find_traces_1_round(), force_nonfallthru(), forwarder_block_to(), gate_tm_init(), get_all_loop_exits(), get_ws_args_for(), gimple_can_merge_blocks_p(), gimple_verify_flow_info(), gimplify_size_expressions(), independent_of_stmt_p(), insert_updated_phi_nodes_for(), ipa_analyze_indirect_call_uses(), ipa_simd_modify_function_body(), ipa_simd_modify_stmt_ops(), ipa_tm_scan_irr_function(), ipa_tm_transform_clone(), maybe_optimize_guarding_check(), maybe_optimize_range_tests(), merge_if_block(), noce_find_if_block(), oacc_entry_exit_single_gang(), oacc_loop_discover_walk(), oacc_loop_xform_head_tail(), omp_make_gimple_edges(), omp_sese_split_blocks(), optimize_spaceship(), outgoing_edges_match(), predicate_bbs(), redirect_edge_and_branch_force(), remap_ssa_name(), remove_bb(), ipa_param_body_adjustments::reset_debug_stmts(), returning_call_p(), rewrite_debug_stmt_uses(), rotate_loop(), rtl_can_merge_blocks(), set_location_for_edge(), simd_clone_adjust(), single_succ_to_potentially_threadable_block(), sjlj_emit_function_enter(), slsr_process_phi(), split_edge(), split_live_ranges_for_shrink_wrap(), spread_components(), suitable_cond_bb(), tm_region_init(), transform_to_exit_first_loop(), tree_forwarder_block_p(), tree_function_versioning(), tree_optimize_tail_calls_1(), try_crossjump_to_edge(), try_forward_edges(), try_optimize_cfg(), try_simplify_condjump(), vect_create_epilog_for_reduction(), verify_loop_structure(), verify_sese(), versionable_outer_loop_p(), warn_return_addr_local(), warn_uninit_phi_uses(), and warn_uninitialized_vars().

◆ single_succ_edge()

edge single_succ_edge ( const_basic_block bb)
inline
Returns the single successor edge of basic block BB.  Aborts if
BB does not have exactly one successor.   

References EDGE_SUCC, gcc_checking_assert, and single_succ_p().

Referenced by add_test(), asan_maybe_insert_dynamic_shadow_at_function_entry(), loop_distribution::bb_top_order_init(), branch_fixup(), branch_prob(), build_and_add_sum(), tree_switch_conversion::switch_conversion::build_arrays(), tree_switch_conversion::switch_conversion::build_constructors(), builtin_unreachable_bb_p(), cfg_layout_can_merge_blocks_p(), rt_bb_visited::check(), cleanup_control_expr_graph(), cleanup_empty_eh(), tree_switch_conversion::switch_conversion::collect(), combine_predictions_for_insn(), commit_one_edge_insertion(), compute_antic_aux(), compute_control_dep_chain_pdom(), compute_outgoing_frequencies(), compute_partial_antic_aux(), cond_exec_find_if_block(), cond_if_else_store_replacement(), cond_move_process_if_block(), contains_no_active_insn_p(), convert_if_conditions_to_switch(), copy_edges_for_bb(), create_empty_if_region_on_edge(), create_empty_loop_on_edge(), create_parallel_loop(), create_preheader(), cse_find_path(), do_rpo_vn_1(), do_split_loop_on_cond(), doloop_modify(), back_jt_path_registry::duplicate_thread_path(), eliminate_tail_call(), tree_switch_conversion::switch_decision_tree::emit_case_nodes(), tree_switch_conversion::switch_decision_tree::emit_jump(), estimate_bb_frequencies(), execute_sm_if_changed(), expand_complex_multiplication(), expand_gimple_basic_block(), expand_oacc_for(), expand_omp_atomic_pipeline(), expand_omp_for_generic(), expand_omp_for_static_chunk(), expand_omp_sections(), expand_omp_simd(), expand_omp_single(), expand_omp_synch(), expand_omp_target(), expand_omp_taskreg(), expand_thunk(), final_range_test_p(), find_always_executed_bbs(), find_cond_trap(), find_if_case_1(), find_if_case_2(), find_tail_calls(), find_taken_edge(), find_traces_1_round(), finish_eh_generation(), fix_up_fall_thru_edges(), fold_marked_statements(), tree_switch_conversion::switch_conversion::gather_default_values(), get_last_alloca_addr(), gimple_can_merge_blocks_p(), gimple_duplicate_sese_tail(), gimple_gen_ic_func_profiler(), gimple_gen_time_profiler(), gimple_lower_bitint(), gimple_lv_add_condition_to_bb(), gimple_merge_blocks(), gimple_verify_flow_info(), gsi_commit_edge_inserts(), gsi_safe_insert_before(), gsi_safe_insert_seq_before(), hardcfr_sibcall_search_block(), infinite_empty_loop_p(), initialize_constant_pool_replacements(), initialize_parameter_reductions(), insert_check_and_trap(), insert_edge_check_and_trap(), rt_bb_visited::insert_exit_check_on_edge(), insert_insn_end_basic_block(), insert_iv_increment(), instrument_func_entry(), loop_preheader_edge(), loop_version(), lower_eh_dispatch(), lower_resx(), lv_adjust_loop_entry_edge(), make_forwarders_with_degenerate_phis(), maybe_optimize_guarding_check(), merge_if_block(), move_sese_in_condition(), noce_convert_multiple_sets(), noce_find_if_block(), noce_process_if_block(), omp_make_gimple_edges(), optimize_spaceship(), optimize_stack_restore(), outgoing_edges_match(), purge_dead_edges(), remove_ctrl_stmt_and_useless_edges(), remove_dead_stmt(), remove_forwarder_block(), remove_forwarder_block_with_phi(), returning_call_p(), rotate_loop(), rtl_can_merge_blocks(), rtl_split_edge(), separate_decls_in_region(), simd_clone_adjust(), single_succ(), single_succ_to_potentially_threadable_block(), sink_clobbers(), sjlj_emit_function_enter(), slpeel_tree_duplicate_loop_to_edge_cfg(), split_edge(), split_loop_exit_edge(), ssa_fix_duplicate_block_edges(), suitable_cond_bb(), jump_threader::thread_around_empty_blocks(), jump_threader::thread_outgoing_edges(), thread_prologue_and_epilogue_insns(), fwd_jt_path_registry::thread_through_loop_header(), tidy_fallthru_edges(), transform_to_exit_first_loop(), transform_to_exit_first_loop_alt(), tree_forwarder_block_p(), tree_function_versioning(), tree_optimize_tail_calls_1(), try_crossjump_to_edge(), try_forward_edges(), try_optimize_cfg(), try_redirect_by_replacing_jump(), try_shrink_wrapping(), tree_switch_conversion::switch_decision_tree::try_switch_expansion(), try_transform_to_exit_first_loop_alt(), unloop(), unroll_loop_runtime_iterations(), unsplit_eh(), update_cfg_for_uncondjump(), update_parameter_components(), value_replacement(), vect_create_epilog_for_reduction(), vect_do_peeling(), vect_slp_function(), vt_find_locations(), worker_single_copy(), and worker_single_simple().

◆ single_succ_p()

bool single_succ_p ( const_basic_block bb)
inline
Returns true if BB has precisely one successor.   

References EDGE_COUNT, and basic_block_def::succs.

Referenced by add_labels_and_missing_jumps(), branch_prob(), gori_map::calculate_gori(), can_move_invariant_reg(), cfg_layout_can_merge_blocks_p(), cleanup_control_expr_graph(), cleanup_tree_cfg_bb(), clobber_only_eh_bb_p(), tree_switch_conversion::switch_conversion::collect(), combine_predictions_for_insn(), commit_one_edge_insertion(), compute_alignments(), compute_antic_aux(), compute_control_dep_chain(), compute_control_dep_chain_pdom(), compute_outgoing_frequencies(), compute_partial_antic_aux(), cond_exec_find_if_block(), contains_no_active_insn_p(), copy_edges_for_bb(), create_preheader(), cse_find_path(), dead_or_predicable(), decrease_profile(), tree_switch_conversion::switch_decision_tree::do_jump_if_equal(), dse_step1(), back_jt_path_registry::duplicate_thread_path(), gimple_outgoing_range::edge_range_p(), tree_switch_conversion::switch_decision_tree::emit_cmp_and_jump_insns(), execute_over_cond_phis(), expand_gimple_basic_block(), expand_omp_taskreg(), final_range_test_p(), find_block_to_duplicate_for_splitting_paths(), find_if_case_1(), find_if_case_2(), find_loop_guard(), find_tail_calls(), find_taken_edge(), find_traces_1_round(), force_single_succ_latches(), forwarder_block_to(), gimple_can_merge_blocks_p(), gimple_find_edge_insert_loc(), gimple_verify_flow_info(), hardcfr_sibcall_search_block(), infinite_empty_loop_p(), predicate::init_from_control_deps(), uninit_analysis::init_use_preds(), insert_insn_end_basic_block(), ipa_analyze_indirect_call_uses(), crc_optimization::loop_contains_two_conditional_bb(), maybe_diag_stxncpy_trunc(), maybe_duplicate_computed_goto(), maybe_optimize_guarding_check(), merge_if_block(), noce_find_if_block(), optimize_spaceship(), outgoing_edges_match(), phi_result_unknown_predicate(), potentially_threadable_block(), predicate_bbs(), predict_loops(), purge_dead_edges(), remap_ssa_name(), remove_ctrl_stmt_and_useless_edges(), remove_dead_stmt(), remove_forwarder_block(), remove_forwarder_block_with_phi(), reorder_basic_blocks_simple(), replace_phi_edge_with_variable(), ipa_param_body_adjustments::reset_debug_stmts(), returning_call_p(), rewrite_debug_stmt_uses(), rotate_loop(), rtl_can_merge_blocks(), rtl_tidy_fallthru_edge(), scan_function(), set_location_for_edge(), should_duplicate_loop_header_p(), simple_control_dep_chain(), single_succ_edge(), single_succ_to_potentially_threadable_block(), sink_clobbers(), slpeel_tree_duplicate_loop_to_edge_cfg(), suitable_cond_bb(), jump_threader::thread_around_empty_blocks(), thread_prologue_and_epilogue_insns(), fwd_jt_path_registry::thread_through_loop_header(), tidy_fallthru_edges(), tree_forwarder_block_p(), tree_ssa_ifcombine_bb(), try_forward_edges(), try_optimize_cfg(), try_redirect_by_replacing_jump(), unsplit_eh(), vect_analyze_loop_form(), vect_create_epilog_for_reduction(), vect_gen_prolog_loop_niters(), vect_loop_vectorized_call(), verify_loop_structure(), verify_sese(), versionable_outer_loop_p(), and walk_to_nondebug_insn().

◆ STATIC_ASSERT()

STATIC_ASSERT ( sizeof(rtl_bb_info) >=sizeof(gimple_bb_info) )
This ensures that struct gimple_bb_info is smaller than
struct rtl_bb_info, so that inlining the former into basic_block_def
is the better choice.