#include <profile-count.h>
#include "cfg-flags.def"

Include dependency graph for basic-block.h:

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) EDGE_##NAME = 1 << 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) BB_##NAME = 1 << 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) ((bb)->flags & (BB_HOT_PARTITION\|BB_COLD_PARTITION))

#define	BB_SET_PARTITION(bb, part)

#define	BB_COPY_PARTITION(dstbb, srcbb) BB_SET_PARTITION (dstbb, BB_PARTITION (srcbb))

#define	ENTRY_BLOCK_PTR_FOR_FN(FN) ((FN)->cfg->x_entry_block_ptr)

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

#define	basic_block_info_for_fn(FN) ((FN)->cfg->x_basic_block_info)

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

#define	n_edges_for_fn(FN) ((FN)->cfg->x_n_edges)

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

#define	label_to_block_map_for_fn(FN) ((FN)->cfg->x_label_to_block_map)

#define	profile_status_for_fn(FN) ((FN)->cfg->x_profile_status)

#define	BASIC_BLOCK_FOR_FN(FN, N) ((*basic_block_info_for_fn (FN))[(N)])

#define	SET_BASIC_BLOCK_FOR_FN(FN, N, BB) ((*basic_block_info_for_fn (FN))[(N)] = (BB))

#define	FOR_BB_BETWEEN(BB, FROM, TO, DIR) for (BB = FROM; BB != TO; BB = BB->DIR)

#define	FOR_EACH_BB_FN(BB, FN) FOR_BB_BETWEEN (BB, (FN)->cfg->x_entry_block_ptr->next_bb, (FN)->cfg->x_exit_block_ptr, next_bb)

#define	FOR_EACH_BB_REVERSE_FN(BB, FN) FOR_BB_BETWEEN (BB, (FN)->cfg->x_exit_block_ptr->prev_bb, (FN)->cfg->x_entry_block_ptr, prev_bb)

#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) for (BB = ENTRY_BLOCK_PTR_FOR_FN (FN); BB; BB = BB->next_bb)

#define	BB_HEAD(B) (B)->il.x.head_

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

#define	BB_HEADER(B) (B)->il.x.rtl->header_

#define	BB_FOOTER(B) (B)->il.x.rtl->footer_

#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) (find_edge_index ((el), (pred), (succ)))

#define	INDEX_EDGE_PRED_BB(el, index) ((el)->index_to_edge[(index)]->src)

#define	INDEX_EDGE_SUCC_BB(el, index) ((el)->index_to_edge[(index)]->dest)

#define	INDEX_EDGE(el, index) ((el)->index_to_edge[(index)])

#define	NUM_EDGES(el) ((el)->num_edges)

#define	FALLTHRU_EDGE(bb)

#define	BRANCH_EDGE(bb)

#define	EDGE_FREQUENCY(e) e->count ().to_frequency (cfun)

#define	GCOV_COMPUTE_SCALE(num, den) ((den) ? RDIV ((num) * REG_BR_PROB_BASE, (den)) : REG_BR_PROB_BASE)

#define	EDGE_CRITICAL_P(e)

#define	EDGE_COUNT(ev) vec_safe_length (ev)

#define	EDGE_I(ev, i) (*ev)[(i)]

#define	EDGE_PRED(bb, i) (*(bb)->preds)[(i)]

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

#define	ei_start(iter) ei_start_1 (&(iter))

#define	ei_last(iter) ei_last_1 (&(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 ) ((*basic_block_info_for_fn (FN))[(N)])

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(), 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_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

#define basic_block_info_for_fn ( FN ) ((FN)->cfg->x_basic_block_info)

Referenced by build_gimple_cfg(), create_bb(), dump_function_to_file(), find_conditions(), fix_loop_structure(), free_cfg(), init_empty_tree_cfg_for_function(), input_cfg(), function_reader::parse_block(), and rtl_create_basic_block().

◆ 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 ) BB_SET_PARTITION (dstbb, BB_PARTITION (srcbb))

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 ) (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(), 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)

ggc_alloc

T * ggc_alloc(ALONE_CXX_MEM_STAT_INFO)

Definition ggc.h:184

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

#define BB_FOOTER ( B ) (B)->il.x.rtl->footer_

Referenced by cfg_layout_delete_block(), cfg_layout_duplicate_bb(), cfg_layout_merge_blocks(), cfg_layout_split_block(), emit_barrier_after_bb(), fixup_fallthru_exit_predecessor(), fixup_reorder_chain(), mark_all_labels(), record_effective_endpoints(), relink_block_chain(), remove_barriers_from_footer(), rtl_verify_bb_pointers(), try_optimize_cfg(), and update_cfg_for_uncondjump().

◆ BB_FREQ_MAX

#define BB_FREQ_MAX 10000

Referenced by bb_to_key(), expand_thunk(), and profile_count::to_frequency().

◆ BB_HEAD

#define BB_HEAD ( B ) (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_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

#define BB_HEADER ( B ) (B)->il.x.rtl->header_

Referenced by cfg_layout_delete_block(), cfg_layout_duplicate_bb(), cfg_layout_merge_blocks(), fixup_reorder_chain(), mark_all_labels(), record_effective_endpoints(), relink_block_chain(), and rtl_verify_bb_pointers().

◆ BB_PARTITION

#define BB_PARTITION ( bb ) ((bb)->flags & (BB_HOT_PARTITION|BB_COLD_PARTITION))

Partitions, to be used when partitioning hot and cold basic blocks into
separate sections.

Referenced by assemble_start_function(), bb_to_key(), cfg_layout_can_merge_blocks_p(), cfg_layout_redirect_edge_and_branch(), rt_bb_visited::check(), check_bb_profile(), connect_traces(), create_eh_forwarder_block(), draw_cfg_node(), dw2_fix_up_crossing_landing_pad(), find_bbs_reachable_by_hot_paths(), find_if_case_1(), find_partition_fixes(), find_rarely_executed_basic_blocks_and_crossing_edges(), find_traces_1_round(), fix_up_fall_thru_edges(), fixup_new_cold_bb(), fixup_partition_crossing(), fixup_partitions(), flow_find_cross_jump(), insert_check_and_trap(), insert_section_boundary_note(), last_bb_in_partition(), merge_blocks_move(), merge_blocks_move_predecessor_nojumps(), merge_blocks_move_successor_nojumps(), reorder_basic_blocks_simple(), rtl_can_merge_blocks(), rtl_can_remove_branch_p(), rtl_split_edge(), rtl_verify_edges(), sanitize_hot_paths(), sjlj_fix_up_crossing_landing_pad(), try_crossjump_bb(), try_crossjump_to_edge(), try_forward_edges(), try_redirect_by_replacing_jump(), try_simplify_condjump(), and verify_hot_cold_block_grouping().

◆ 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)

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

#define BRANCH_EDGE ( bb )

Value:

(EDGE_SUCC ((bb), 0)->flags & EDGE_FALLTHRU \

? EDGE_SUCC ((bb), 1) : EDGE_SUCC ((bb), 0))

EDGE_SUCC

#define EDGE_SUCC(bb, i)

Definition basic-block.h:308

BB is assumed to contain conditional jump.  Return the branch edge.

Referenced by combine_predictions_for_insn(), compute_outgoing_frequencies(), cse_extended_basic_block(), cse_find_path(), dead_or_predicable(), discover_loop(), expand_oacc_for(), expand_omp_for(), expand_omp_for_generic(), expand_omp_for_static_chunk(), expand_omp_for_static_nochunk(), expand_omp_simd(), expand_omp_taskloop_for_inner(), expand_omp_taskloop_for_outer(), expand_omp_taskreg(), find_implicit_sets(), lower_eh_dispatch(), outgoing_edges_match(), purge_dead_edges(), rtl_verify_edges(), thread_jump(), try_optimize_cfg(), try_simplify_condjump(), and update_br_prob_note().

◆ CLEANUP_CFG_CHANGED

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

Referenced by cleanup_cfg(), execute_rtl_cprop(), peephole2_optimize(), rest_of_handle_cse(), rest_of_handle_cse2(), and rest_of_handle_cse_after_global_opts().

◆ CLEANUP_CFGLAYOUT

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

Referenced by cfg_layout_initialize(), cleanup_cfg(), and try_optimize_cfg().

◆ 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 */

Referenced by try_forward_edges(), and try_optimize_cfg().

◆ DEF_BASIC_BLOCK_FLAG

#define DEF_BASIC_BLOCK_FLAG	(		NAME,
			IDX ) BB_##NAME = 1 << IDX ,

Masks for basic_block.flags.

◆ DEF_EDGE_FLAG

#define DEF_EDGE_FLAG	(		NAME,
			IDX ) 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

#define EDGE_COMPLEX (EDGE_ABNORMAL | EDGE_ABNORMAL_CALL | EDGE_EH | EDGE_PRESERVE)

The following four flags all indicate something special about an edge.
Test the edge flags on EDGE_COMPLEX to detect all forms of "strange"
control flow transfers.

Referenced by analyze_insns_in_loop(), block_jumps_and_fallthru(), bypass_block(), can_dup_for_shrink_wrapping(), can_get_prologue(), cfg_layout_can_merge_blocks_p(), cfg_layout_redirect_edge_and_branch(), compute_branch_probabilities(), compute_outgoing_frequencies(), cond_exec_find_if_block(), connect_traces(), create_preheader(), cse_cc_succs(), final_range_test_p(), find_block_to_duplicate_for_splitting_paths(), find_if_case_1(), find_if_case_2(), find_if_header(), find_trace(), find_traces_1_round(), gimple_can_merge_blocks_p(), instrument_decisions(), maybe_duplicate_computed_goto(), noce_find_if_block(), outgoing_edges_match(), phi_dynamic_object_size(), purge_dead_edges(), reachable_at_most_once(), remove_fallthru_edge(), rotate_loop(), rtl_can_merge_blocks(), same_phi_alternatives(), single_noncomplex_succ(), single_succ_to_potentially_threadable_block(), split_edge_bb_loc(), jump_threader::thread_across_edge(), jump_threader::thread_outgoing_edges(), tidy_fallthru_edges(), try_forward_edges(), try_optimize_cfg(), unsupported_edge(), and vect_loop_versioning().

◆ EDGE_COUNT

#define EDGE_COUNT ( ev ) vec_safe_length (ev)

Referenced by _eligible_successor_edge_p(), 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(), 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(), 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(), 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_stack_restore(), outgoing_edges_match(), output_cfg(), phi_convertible_by_degenerating_args(), 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(), dom_ranger::range_in_bb(), recognize_if_then_else(), 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 )

Value:

(EDGE_COUNT ((e)->src->succs) >= 2 \

&& EDGE_COUNT ((e)->dest->preds) >= 2)

EDGE_COUNT

#define EDGE_COUNT(ev)

Definition basic-block.h:305

Return nonzero if edge is critical.

Referenced by coalesce_cost_edge(), compare_freqs(), create_loop_tree_nodes(), eliminate_partially_redundant_load(), emit_moves(), ifcvt_split_critical_edges(), insert_backedge_copies(), insert_insn_on_edge(), instrument_edges(), ira(), lra_process_new_insns(), prepend_insn_to_edge(), and split_critical_edges().

◆ EDGE_FREQUENCY

#define EDGE_FREQUENCY ( e ) e->count ().to_frequency (cfun)

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 ) (*ev)[(i)]

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

◆ EDGE_INDEX

#define EDGE_INDEX	(	el,
		pred,
		succ ) (find_edge_index ((el), (pred), (succ)))

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

#define EDGE_PRED	(		bb,
			i ) (*(bb)->preds)[(i)]

Referenced by add_ssa_edge(), bitmap_intersection_of_preds(), bitmap_union_of_preds(), builtin_setjmp_setup_bb(), check_loop_closed_ssa_def(), compute_complex_ancestor_jump_func(), connect_loop_phis(), construct_exit_block(), create_phi_for_local_result(), create_preheader(), delete_basic_block(), disconnect_dest(), extract_true_false_controlled_edges(), find_block_to_duplicate_for_splitting_paths(), find_split_points(), gimple_lower_bitint(), gimple_phi_arg_edge(), hardcfr_sibcall_search_preds(), inherit_in_ebb(), input_phi(), rt_bb_visited::insert_exit_check_on_edge(), insert_into_preds_of_block(), ipa_analyze_indirect_call_uses(), is_feasible_trace(), lower_emutls_function_body(), minmax_replacement(), predicate_scalar_phi(), ranger_cache::range_from_dom(), dom_ranger::range_in_bb(), record_edge_info(), remove_forwarder_block_with_phi(), replace_block_by(), returning_call_p(), simd_clone_adjust(), single_block_loop_p(), single_pred_edge(), sink_common_stores_to_bb(), slpeel_tree_duplicate_loop_to_edge_cfg(), split_paths(), stmt_local_def(), tm_memopt_compute_avin(), try_crossjump_bb(), try_crossjump_to_edge(), try_head_merge_bb(), value_replacement(), vect_analyze_loop_form(), vect_do_peeling(), vect_loop_versioning(), verify_phi_args(), rt_bb_visited::visit(), and visit_phi().

◆ EDGE_SUCC

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

Referenced by _eligible_successor_edge_p(), 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(), dom_ranger::edge_range(), eliminate_dom_walker::eliminate_stmt(), emit_nop_for_unique_locus_between(), 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(), 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(), dom_ranger::pre_bb(), fold_using_range::range_of_range_op(), dom_ranger::range_of_stmt(), 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_loop_versioning(), vectorizable_early_exit(), and rt_bb_visited::visit().

◆ ei_last

#define ei_last ( iter ) ei_last_1 (&(iter))

◆ ei_start

#define ei_start ( iter ) ei_start_1 (&(iter))

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

#define ENTRY_BLOCK (0)

Special block numbers [markers] for entry and exit.
Neither of them is supposed to hold actual statements.

Referenced by cancel_negative_cycle(), compact_blocks(), compute_avail(), copy_cfg_body(), copy_edges_for_bb(), create_fixup_graph(), df_bb_refs_collect(), df_compact_blocks(), df_record_entry_block_defs(), df_scan_blocks(), df_update_entry_block_defs(), df_word_lr_alloc(), draw_cfg_edges(), draw_cfg_node(), dse_step1(), dse_step3(), dump_edge_info(), virtual_operand_live::init(), init_empty_tree_cfg_for_function(), init_flow(), function_reader::parse_bb_idx(), post_order_compute(), pre_and_rev_post_order_compute_fn(), print_basic_block(), print_edge(), prune_unused_phi_nodes(), region_contains_p(), rtl_dump_bb(), update_ssa_across_abnormal_edges(), and update_worklist().

◆ ENTRY_BLOCK_PTR_FOR_FN

#define ENTRY_BLOCK_PTR_FOR_FN ( FN ) ((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(), 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(), 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(), dom_ranger::range_in_bb(), 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(), 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

#define EXIT_BLOCK (1)

Referenced by loop_distribution::bb_top_order_init(), compact_blocks(), copy_cfg_body(), copy_edges_for_bb(), create_fixup_graph(), df_bb_refs_collect(), df_compact_blocks(), df_lr_local_compute(), df_record_exit_block_uses(), df_scan_blocks(), df_update_exit_block_uses(), df_word_lr_alloc(), df_word_lr_local_compute(), do_rpo_vn_1(), draw_cfg_edges(), draw_cfg_node(), dse_confluence_0(), dse_step1(), dse_step3(), dump_edge_info(), find_always_executed_bbs(), init_empty_tree_cfg_for_function(), init_flow(), insert(), inverted_rev_post_order_compute(), function_reader::parse_bb_idx(), function_reader::parse_edge(), back_threader_profitability::possibly_profitable_path_p(), post_order_compute(), pre_and_rev_post_order_compute_fn(), print_basic_block(), print_edge(), region_contains_p(), rtl_dump_bb(), vect_slp_function(), vt_find_locations(), and warn_uninitialized_vars().

◆ EXIT_BLOCK_PTR_FOR_FN

#define EXIT_BLOCK_PTR_FOR_FN ( FN ) ((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

#define FALLTHRU_EDGE ( bb )

Value:

(EDGE_SUCC ((bb), 0)->flags & EDGE_FALLTHRU \

? EDGE_SUCC ((bb), 0) : EDGE_SUCC ((bb), 1))

BB is assumed to contain conditional jump.  Return the fallthru edge.

Referenced by bb_next_bb(), bypass_block(), combine_predictions_for_insn(), compute_outgoing_frequencies(), create_call_for_reduction(), create_phi_for_local_result(), cse_find_path(), dead_or_predicable(), discover_loop(), discover_loops(), expand_oacc_for(), expand_omp_for(), expand_omp_for_generic(), expand_omp_for_static_chunk(), expand_omp_for_static_nochunk(), expand_omp_simd(), expand_omp_taskloop_for_inner(), expand_omp_taskloop_for_outer(), expand_omp_taskreg(), find_if_case_1(), find_implicit_sets(), lower_eh_dispatch(), outgoing_edges_match(), purge_dead_edges(), simd_clone_adjust(), thread_jump(), tm_region_init_0(), try_optimize_cfg(), and try_simplify_condjump().

◆ FOR_ALL_BB_FN

#define FOR_ALL_BB_FN	(		BB,
			FN ) for (BB = ENTRY_BLOCK_PTR_FOR_FN (FN); BB; BB = BB->next_bb)

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(), execute_ranger_vrp(), 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

#define FOR_BB_BETWEEN	(	BB,
		FROM,
		TO,
		DIR ) for (BB = FROM; BB != TO; BB = BB->DIR)

For iterating over basic blocks.

Referenced by adjust_cfg_counts(), alloc_aux_for_edges(), branch_prob(), bypass_conditional_jumps(), clear_aux_for_edges(), commit_edge_insertions(), compute_branch_probabilities(), control_dependences::control_dependences(), correct_negative_edge_counts(), create_edge_list(), create_fixup_graph(), eliminate_partially_redundant_loads(), estimate_bb_frequencies(), expand_phi_nodes(), find_many_sub_basic_blocks(), find_spanning_tree(), get_exec_counts(), instrument_edges(), inverted_rev_post_order_compute(), last_bb_in_partition(), make_edges(), mark_irreducible_loops(), one_cprop_pass(), read_profile_edge_counts(), rebuild_frequencies(), remove_fake_edges(), set_bb_counts(), tidy_fallthru_edges(), update_max_bb_count(), verify_edge_list(), verify_flow_info(), and vt_initialize().

◆ 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))

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_subregs_of_mode(), initialize_uninitialized_regs(), local_cprop_pass(), loop_exit_at_end_p(), make_more_copies(), mark_all_labels(), maybe_duplicate_computed_goto(), need_cmov_or_rewire(), 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

#define FOR_BB_INSNS_REVERSE	(		BB,
			INSN )

Value:

  for ((INSN) = BB_END (BB);                    \
       (INSN) && (INSN) != PREV_INSN (BB_HEAD (BB));    \
       (INSN) = PREV_INSN (INSN))

Referenced by bb_is_just_return(), build_insn_chain(), calculate_bb_reg_pressure(), compute_hash_table_work(), compute_regs_asm_clobbered(), create_bb_allocnos(), create_log_links(), dce_process_block(), dead_or_predicable(), df_bb_regno_last_def_find(), df_bb_verify(), df_lr_bb_local_compute(), df_note_bb_compute(), df_rd_bb_local_compute(), df_word_lr_bb_local_compute(), get_last_insertion_point(), get_loop_location(), ira_emit(), move_insn_for_shrink_wrap(), process_bb_node_lives(), regstat_bb_compute_calls_crossed(), regstat_bb_compute_ri(), remove_inheritance_pseudos(), simplify_using_initial_values(), and word_dce_process_block().

◆ 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)

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 ) FOR_BB_BETWEEN (BB, (FN)->cfg->x_entry_block_ptr->next_bb, (FN)->cfg->x_exit_block_ptr, next_bb)

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(), draw_cfg_edges(), dse_step5(), ssa_block_ranges::dump(), gori_map::dump(), gimple_ranger::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(), finalize_sccopy(), 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_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(), and warn_uninitialized_vars().

◆ FOR_EACH_BB_REVERSE_FN

#define FOR_EACH_BB_REVERSE_FN	(		BB,
			FN ) FOR_BB_BETWEEN (BB, (FN)->cfg->x_exit_block_ptr->prev_bb, (FN)->cfg->x_entry_block_ptr, prev_bb)

Referenced by build_insn_chain(), compute_code_hoist_vbeinout(), delete_unmarked_insns(), execute_omp_device_lower(), final_1(), gimple_lower_bitint(), indirect_jump_optimize(), peephole2_optimize(), print_rtl_with_bb(), reload_combine(), reset_unmarked_insns_debug_uses(), rtl_verify_bb_insn_chain(), rtl_verify_bb_insns(), rtl_verify_bb_pointers(), rtl_verify_edges(), rtl_verify_fallthru(), split_all_insns(), try_shrink_wrapping(), and verify_flow_info().

◆ 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)))

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(), find_comparison_dom_walker::before_dom_children(), nontrapping_dom_walker::before_dom_children(), eliminate_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(), execute_early_expand_coro_ifns(), execute_ranger_vrp(), expand_asm_stmt(), expand_call_tm(), expand_complex_libcall(), expand_gimple_basic_block(), expand_omp_sections(), expand_phi_nodes(), expand_transaction(), 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(), 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(), 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(), visit_phi(), 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 ) ((den) ? RDIV ((num) * REG_BR_PROB_BASE, (den)) : REG_BR_PROB_BASE)

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 ) ((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 ) ((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 ) ((el)->index_to_edge[(index)]->dest)

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

◆ label_to_block_map_for_fn

#define label_to_block_map_for_fn ( FN ) ((FN)->cfg->x_label_to_block_map)

Referenced by delete_tree_cfg_annotations(), gimple_set_bb(), init_empty_tree_cfg_for_function(), input_cfg(), and verify_gimple_label().

◆ last_basic_block_for_fn

#define last_basic_block_for_fn ( FN ) ((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(), 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(), fill_always_executed_in(), find_implicit_sets(), find_many_sub_basic_blocks(), find_moveable_pseudos(), 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_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(), mark_phi_for_rewrite(), 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 ) ((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_rpo_vn_1(), draw_cfg_nodes_no_loops(), dump_cfg_stats(), dump_flow_info(), dump_function_to_file(), entry_of_function(), execute_split_paths(), expunge_block(), 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(), 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

#define n_edges_for_fn ( FN ) ((FN)->cfg->x_n_edges)

Referenced by create_fixup_graph(), df_worklist_dataflow_doublequeue(), dump_flow_info(), free_cfg(), free_edge(), gcse_or_cprop_is_too_expensive(), gimple_dump_cfg(), ipa_icf::sem_function::init(), init_flow(), prune_insertions_deletions(), gimple_outgoing_range::switch_edge_range(), unchecked_make_edge(), and variable_tracking_main_1().

◆ NUM_EDGES

#define NUM_EDGES ( el ) ((el)->num_edges)

Number of edges in the compressed edge list.

Referenced by branch_prob(), compute_earliest(), compute_farthest(), compute_insert_delete(), compute_laterin(), compute_nearerout(), compute_rev_insert_delete(), find_edge_index(), find_spanning_tree(), instrument_edges(), one_store_motion_pass(), pre_edge_insert(), pre_edge_lcm_avs(), and pre_edge_rev_lcm().

◆ NUM_FIXED_BLOCKS

#define NUM_FIXED_BLOCKS (2)

The two blocks that are always in the cfg.

Referenced by add_store_equivs(), analyze_memory_references(), loop_distribution::bb_top_order_init(), build_gimple_cfg(), cleanup_control_flow_pre(), cleanup_tree_cfg_noloop(), compact_blocks(), compute_antinout_edge(), compute_available(), compute_branch_probabilities(), compute_laterin(), dbr_schedule(), delete_output_reload(), df_bb_refs_collect(), df_compact_blocks(), do_rpo_vn_1(), dse_step1(), dump_reg_info(), entry_of_function(), equiv_init_movable_p(), execute_split_paths(), fast_dce(), find_if_case_2(), flow_loops_find(), generate_setjmp_warnings(), gimple_dump_bb(), gimple_flow_call_edges_add(), hardcfr_sibcall_search_preds(), ignore_bb_p(), init_empty_tree_cfg_for_function(), init_reassoc(), init_var_map(), insert_updated_phi_nodes_for(), label_to_block(), make_edges(), maybe_duplicate_computed_goto(), rt_bb_visited::num2idx(), one_code_hoisting_pass(), one_cprop_pass(), one_pre_gcse_pass(), pre_and_rev_post_order_compute(), pre_and_rev_post_order_compute_fn(), predict_loops(), predict_paths_for_bb(), print_loop_title(), relink_block_chain(), remove_bb(), reorder_basic_blocks(), returning_call_p(), rt_bb_visited::rt_bb_visited(), rtl_flow_call_edges_add(), rtl_verify_bb_layout(), single_pred_before_succ_order(), sort_sibling_loops(), thread_prologue_and_epilogue_insns(), try_forward_edges(), try_optimize_cfg(), update_equiv_regs(), and vt_find_locations().

◆ profile_status_for_fn

#define profile_status_for_fn ( FN ) ((FN)->cfg->x_profile_status)

◆ SET_BASIC_BLOCK_FOR_FN

#define SET_BASIC_BLOCK_FOR_FN	(	FN,
		N,
		BB ) ((*basic_block_info_for_fn (FN))[(N)] = (BB))

Referenced by compact_blocks(), create_basic_block_structure(), create_bb(), df_bb_replace(), df_compact_blocks(), expunge_block(), init_empty_tree_cfg_for_function(), make_new_block(), and function_reader::parse_block().

Enumeration Type Documentation

◆ cfg_bb_flags

enum cfg_bb_flags

Enumerator
LAST_CFG_BB_FLAG

◆ cfg_edge_flags

enum cfg_edge_flags

Enumerator
LAST_CFG_EDGE_FLAG

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.

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()

bool bb_has_abnormal_pred ( basic_block bb )

inline

Return true when one of the predecessor edges of BB is marked with EDGE_ABNORMAL.

Referenced by bb_loop_header_p(), rewrite_update_dom_walker::before_dom_children(), create_new_def_for(), find_clusters_1(), gimple_verify_flow_info(), gsi_safe_insert_before(), gsi_safe_insert_seq_before(), has_nonexceptional_receiver(), make_forwarders_with_degenerate_phis(), process_bb_lives(), process_bb_node_lives(), remove_forwarder_block(), and select_best_block().

◆ 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, and ggc_alloc().

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(), 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.

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()

vec< edge, va_gc > * ei_container ( edge_iterator i )

inline

References gcc_checking_assert, and i.

Referenced by cleanup_control_flow_pre(), ei_edge(), ei_end_p(), ei_next(), ei_one_before_end_p(), and remove_reachable_equiv_notes().

◆ ei_edge()

edge ei_edge ( edge_iterator i )

inline

Return the edge pointed to by the iterator `i'.

References EDGE_I, ei_container(), and i.

Referenced by cleanup_control_flow_pre(), dfs_mark_dominating_region(), ei_cond(), ei_safe_edge(), input_function(), inverted_rev_post_order_compute(), loop_inverted_rev_post_order_compute(), loop_rev_post_order_compute(), mark_dfs_back_edges(), post_order_compute(), pre_and_rev_post_order_compute_fn(), remove_reachable_equiv_notes(), rev_post_order_and_mark_dfs_back_seme(), verify_sese(), and vt_stack_adjustments().

◆ 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(), 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, ggc_alloc(), i, and edge_iterator::index.

◆ ei_next()

void ei_next ( edge_iterator * i )

inline

Advance the iterator to the next element.

References EDGE_COUNT, ei_container(), gcc_checking_assert, and i.

Referenced by _succ_iter_cond(), _succ_iter_next(), 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_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(), inverted_rev_post_order_compute(), loop_inverted_rev_post_order_compute(), loop_rev_post_order_compute(), make_forwarder_block(), mark_dfs_back_edges(), maybe_duplicate_computed_goto(), post_order_compute(), pre_and_rev_post_order_compute_fn(), purge_dead_edges(), purge_dead_tablejump_edges(), remove_ctrl_stmt_and_useless_edges(), remove_fake_predecessors(), 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().

◆ ei_one_before_end_p()

bool ei_one_before_end_p ( edge_iterator i )

inline

Is the iterator `i' at one position before the end of the
sequence?

References EDGE_COUNT, ei_container(), and i.

Referenced by cleanup_control_flow_pre(), dfs_mark_dominating_region(), inverted_rev_post_order_compute(), loop_inverted_rev_post_order_compute(), loop_rev_post_order_compute(), mark_dfs_back_edges(), maybe_move_debug_stmts_to_successors(), post_order_compute(), pre_and_rev_post_order_compute_fn(), and vt_stack_adjustments().

◆ 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()

edge ei_safe_edge ( edge_iterator i )

inline

Return an edge pointed to by the iterator.  Do it safely so that
NULL is returned when the iterator is pointing at the end of the
sequence.

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

Referenced by bypass_block(), cleanup_control_expr_graph(), cleanup_control_flow_bb(), cleanup_empty_eh(), cleanup_empty_eh_merge_phis(), combine_blocks(), disconnect_src(), dw2_fix_up_crossing_landing_pad(), eliminate_unnecessary_stmts(), emit_insn_at_entry(), emit_to_new_bb_before(), 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(), isolate_path(), make_forwarder_block(), maybe_duplicate_computed_goto(), move_sese_region_to_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(), simplify_gimple_switch_label_vec(), sjlj_fix_up_crossing_landing_pad(), thread_prologue_and_epilogue_insns(), try_forward_edges(), and try_shrink_wrapping().

◆ 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 ggc_alloc(), i, and edge_iterator::index.

◆ find_fallthru_edge()

edge find_fallthru_edge ( vec< edge, va_gc > * edges )

inline

Return the fallthru edge in EDGES if it exists, NULL otherwise.

Referenced by block_fallthru(), can_guard_call_p(), cfg_layout_can_merge_blocks_p(), dump_implicit_edges(), expand_asm_stmt(), expand_complex_move(), fix_up_fall_thru_edges(), fixup_abnormal_edges(), fixup_fallthru_exit_predecessor(), fixup_reorder_chain(), fold_builtin_atomic_compare_exchange(), gimple_ic(), gimple_lower_bitint(), handle_builtin_alloca(), insert_stmt_after(), instrument_bool_enum_load(), instrument_expr(), lra_inheritance(), merge_blocks_move(), non_eh_succ_edge(), optimize_atomic_bit_test_and(), print_rtl_with_bb(), rtl_split_edge(), rtl_verify_fallthru(), shrink_wrap_one_built_in_call_with_conds(), thread_prologue_and_epilogue_insns(), try_crossjump_bb(), try_crossjump_to_edge(), update_cfg_for_uncondjump(), vect_create_constant_vectors(), walk_to_nondebug_insn(), and warn_uninitialized_vars().

◆ 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.

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, ggc_alloc(), and basic_block_def::succs.

Referenced by find_explicit_erroneous_behavior(), and find_implicit_erroneous_behavior().

◆ inverse_probability()

int inverse_probability ( int prob1 )

inline

Return inverse probability for PROB.

References check_probability(), ggc_alloc(), 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(), ip_normal_pos(), ipa_analyze_indirect_call_uses(), is_feasible_trace(), 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_range_test(), vec_init_loop_exit_info(), vect_analyze_early_break_dependences(), vect_loop_vectorized_call(), verify_sese(), and versionable_outer_loop_p().

◆ single_pred_edge()

edge single_pred_edge ( const_basic_block bb )

inline

Returns the single predecessor edge of basic block BB.  Aborts
if BB does not have exactly one predecessor.

References EDGE_PRED, gcc_checking_assert, and single_pred_p().

Referenced by bound_difference(), assume_query::calculate_stmt(), rt_bb_visited::check(), compute_control_dep_chain_pdom(), cond_exec_find_if_block(), create_empty_loop_on_edge(), create_parallel_loop(), create_tailcall_accumulator(), determine_value_range(), do_split_loop_on_cond(), tree_switch_conversion::switch_decision_tree::emit_case_nodes(), expand_phi_nodes(), find_block_to_duplicate_for_splitting_paths(), find_return_bb(), fold_loop_internal_call(), force_edge_cold(), fuse_loops(), get_bb_avail_insn(), get_range_query(), gimple_find_edge_insert_loc(), gimple_ic(), hoist_memory_references(), insert_edge_check_and_trap(), loop_version(), maybe_optimize_guarding_check(), move_sese_in_condition(), predict_loops(), ranger_cache::range_from_dom(), remove_path(), scale_profile_for_vect_loop(), simple_control_dep_chain(), simplify_using_initial_conditions(), simplify_using_initial_values(), single_pred(), slpeel_tree_duplicate_loop_to_edge_cfg(), split_edge(), split_loop(), transform_to_exit_first_loop_alt(), tree_if_conversion(), tree_optimize_tail_calls_1(), tree_transform_and_unroll_loop(), try_crossjump_to_edge(), try_optimize_cfg(), tree_switch_conversion::switch_decision_tree::try_switch_expansion(), unroll_loop_runtime_iterations(), unsplit_eh(), vect_do_peeling(), and vectorizable_lc_phi().

◆ 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(), assume_query::calculate_stmt(), 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(), is_feasible_trace(), 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(), predict_loops(), propagate_threaded_block_debug_into(), prune_bbs_to_update_dominators(), range_query::query_relation(), ranger_cache::range_from_dom(), fold_using_range::range_of_range_op(), relation_oracle::register_edge(), remove_forwarder_block(), remove_forwarder_block_with_phi(), remove_path(), rename_variables_in_bb(), replace_phi_edge_with_variable(), rtl_can_merge_blocks(), 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(), and vt_initialize().

◆ 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(), 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(), 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(), 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_iv(), 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(), 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_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(), 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(), maybe_diag_stxncpy_trunc(), maybe_duplicate_computed_goto(), maybe_optimize_guarding_check(), merge_if_block(), noce_find_if_block(), 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(), try_forward_edges(), try_optimize_cfg(), try_redirect_by_replacing_jump(), unsplit_eh(), 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.

Data Structures

Macros

Enumerations

Functions

Macro Definition Documentation

◆ BASIC_BLOCK_FOR_FN

◆ basic_block_info_for_fn

◆ BB_ALL_FLAGS

◆ BB_COPY_PARTITION

◆ BB_END

◆ BB_FLAGS_TO_PRESERVE

◆ BB_FOOTER

◆ BB_FREQ_MAX

◆ BB_HEAD

◆ BB_HEADER

◆ BB_PARTITION

◆ BB_SET_PARTITION

◆ BB_UNPARTITIONED

◆ BRANCH_EDGE

◆ CLEANUP_CFG_CHANGED

◆ CLEANUP_CFGLAYOUT

◆ CLEANUP_CROSSJUMP

◆ CLEANUP_EXPENSIVE

◆ CLEANUP_FORCE_FAST_DCE

◆ CLEANUP_NO_INSN_DEL

◆ CLEANUP_NO_PARTITIONING

◆ CLEANUP_POST_REGSTACK

◆ CLEANUP_THREADING

◆ DEF_BASIC_BLOCK_FLAG

◆ DEF_EDGE_FLAG

◆ EDGE_ALL_FLAGS

◆ EDGE_COMPLEX

◆ EDGE_COUNT

◆ EDGE_CRITICAL_P

◆ EDGE_FREQUENCY

◆ EDGE_I

◆ EDGE_INDEX

◆ EDGE_INDEX_NO_EDGE

◆ EDGE_PRED

◆ EDGE_SUCC

◆ ei_last

◆ ei_start

◆ ENTRY_BLOCK

◆ ENTRY_BLOCK_PTR_FOR_FN

◆ EXIT_BLOCK

◆ EXIT_BLOCK_PTR_FOR_FN

◆ FALLTHRU_EDGE

◆ FOR_ALL_BB_FN

◆ FOR_BB_BETWEEN

◆ FOR_BB_INSNS

◆ FOR_BB_INSNS_REVERSE

◆ FOR_BB_INSNS_REVERSE_SAFE

◆ FOR_BB_INSNS_SAFE

◆ FOR_EACH_BB_FN

◆ FOR_EACH_BB_REVERSE_FN

◆ FOR_EACH_EDGE

◆ GCOV_COMPUTE_SCALE

◆ INDEX_EDGE

◆ INDEX_EDGE_PRED_BB

◆ INDEX_EDGE_SUCC_BB

◆ label_to_block_map_for_fn

◆ last_basic_block_for_fn

◆ n_basic_blocks_for_fn

◆ n_edges_for_fn

◆ NUM_EDGES

◆ NUM_FIXED_BLOCKS

◆ profile_status_for_fn

◆ SET_BASIC_BLOCK_FOR_FN

Enumeration Type Documentation

◆ cfg_bb_flags

◆ cfg_edge_flags

Function Documentation

◆ apply_probability()

◆ apply_scale()

◆ bb_has_abnormal_pred()

◆ bb_has_eh_pred()

◆ bb_in_transaction()

◆ check_probability()

◆ combine_probabilities()

◆ ei_cond()