GCC Middle and Back End API Reference
cfghooks.cc File Reference
#include "config.h"
#include "system.h"
#include "coretypes.h"
#include "backend.h"
#include "rtl.h"
#include "cfghooks.h"
#include "timevar.h"
#include "pretty-print.h"
#include "diagnostic-core.h"
#include "dumpfile.h"
#include "cfganal.h"
#include "tree.h"
#include "tree-ssa.h"
#include "cfgloop.h"
#include "sreal.h"
#include "profile.h"
Include dependency graph for cfghooks.cc:


void rtl_register_cfg_hooks (void)
void cfg_layout_rtl_register_cfg_hooks (void)
void gimple_register_cfg_hooks (void)
struct cfg_hooks get_cfg_hooks (void)
void set_cfg_hooks (struct cfg_hooks new_cfg_hooks)
enum ir_type current_ir_type (void)
DEBUG_FUNCTION void verify_flow_info (void)
void dump_bb (FILE *outf, basic_block bb, int indent, dump_flags_t flags)
DEBUG_FUNCTION void debug (basic_block_def &ref)
DEBUG_FUNCTION void debug (basic_block_def *ptr)
static void debug_slim (basic_block ptr)
void dump_bb_for_graph (pretty_printer *pp, basic_block bb)
void dump_flow_info (FILE *file, dump_flags_t flags)
void debug_flow_info (void)
edge redirect_edge_and_branch (edge e, basic_block dest)
bool can_remove_branch_p (const_edge e)
void remove_branch (edge e)
void remove_edge (edge e)
edge redirect_edge_succ_nodup (edge e, basic_block new_succ)
basic_block redirect_edge_and_branch_force (edge e, basic_block dest)
static edge split_block_1 (basic_block bb, void *i)
edge split_block (basic_block bb, gimple *i)
edge split_block (basic_block bb, rtx i)
edge split_block_after_labels (basic_block bb)
bool move_block_after (basic_block bb, basic_block after)
void delete_basic_block (basic_block bb)
basic_block split_edge (edge e)
static basic_block create_basic_block_1 (void *head, void *end, basic_block after)
basic_block create_basic_block (gimple_seq seq, basic_block after)
basic_block create_basic_block (rtx head, rtx end, basic_block after)
basic_block create_empty_bb (basic_block after)
bool can_merge_blocks_p (basic_block bb1, basic_block bb2)
void predict_edge (edge e, enum br_predictor predictor, int probability)
bool predicted_by_p (const_basic_block bb, enum br_predictor predictor)
void merge_blocks (basic_block a, basic_block b)
edge make_forwarder_block (basic_block bb, bool(*redirect_edge_p)(edge), void(*new_bb_cbk)(basic_block))
void tidy_fallthru_edge (edge e)
void tidy_fallthru_edges (void)
basic_block force_nonfallthru (edge e)
bool can_duplicate_block_p (const_basic_block bb)
basic_block duplicate_block (basic_block bb, edge e, basic_block after, copy_bb_data *id)
bool block_ends_with_call_p (basic_block bb)
bool block_ends_with_condjump_p (const_basic_block bb)
int flow_call_edges_add (sbitmap blocks)
void execute_on_growing_pred (edge e)
void execute_on_shrinking_pred (edge e)
void lv_flush_pending_stmts (edge e)
bool cfg_hook_duplicate_loop_body_to_header_edge (class loop *loop, edge e, unsigned int ndupl, sbitmap wont_exit, edge orig, vec< edge > *to_remove, int flags)
void extract_cond_bb_edges (basic_block b, edge *e1, edge *e2)
void lv_adjust_loop_header_phi (basic_block first, basic_block second, basic_block new_block, edge e)
void lv_add_condition_to_bb (basic_block first, basic_block second, basic_block new_block, void *cond)
bool can_copy_bbs_p (basic_block *bbs, unsigned n)
void copy_bbs (basic_block *bbs, unsigned n, basic_block *new_bbs, edge *edges, unsigned num_edges, edge *new_edges, class loop *base, basic_block after, bool update_dominance)
bool empty_block_p (basic_block bb)
basic_block split_block_before_cond_jump (basic_block bb)
void profile_record_check_consistency (profile_record *record)
void profile_record_account_profile (profile_record *record)


static struct cfg_hooks * cfg_hooks

Function Documentation

◆ block_ends_with_call_p()

bool block_ends_with_call_p ( basic_block bb)
Return 1 if BB ends with a call, possibly followed by some
instructions that must stay with the call, 0 otherwise.   

References cfg_hooks::block_ends_with_call_p, internal_error(), and cfg_hooks::name.

Referenced by compute_branch_probabilities(), find_traces_1_round(), is_edge_inconsistent(), and is_inconsistent().

◆ block_ends_with_condjump_p()

bool block_ends_with_condjump_p ( const_basic_block bb)
Return 1 if BB ends with a conditional branch, 0 otherwise.   

References cfg_hooks::block_ends_with_condjump_p, internal_error(), and cfg_hooks::name.

Referenced by compute_branch_probabilities().

◆ can_copy_bbs_p()

◆ can_duplicate_block_p()

◆ can_merge_blocks_p()

◆ can_remove_branch_p()

bool can_remove_branch_p ( const_edge e)
Returns true if it is possible to remove the edge E by redirecting it
to the destination of the other edge going from its source.   

References cfg_hooks::can_remove_branch_p, EDGE_COUNT, internal_error(), and cfg_hooks::name.

Referenced by remove_path().

◆ cfg_hook_duplicate_loop_body_to_header_edge()

bool cfg_hook_duplicate_loop_body_to_header_edge ( class loop * loop,
edge e,
unsigned int ndupl,
sbitmap wont_exit,
edge orig,
vec< edge > * to_remove,
int flags )
Loop versioning uses the duplicate_loop_body_to_header_edge to create
a new version of the loop basic-blocks, the parameters here are
exactly the same as in duplicate_loop_body_to_header_edge or
tree_duplicate_loop_body_to_header_edge; while in tree-ssa there is
additional work to maintain ssa information that's why there is
a need to call the tree_duplicate_loop_body_to_header_edge rather
than duplicate_loop_body_to_header_edge when we are in tree mode.   

References cfg_hooks::cfg_hook_duplicate_loop_body_to_header_edge, and gcc_assert.

Referenced by loop_version().

◆ cfg_layout_rtl_register_cfg_hooks()

void cfg_layout_rtl_register_cfg_hooks ( void )
Initialization of functions specific to the rtl IR.   

References cfg_layout_rtl_cfg_hooks.

Referenced by cfg_layout_initialize(), and skip_pass().

◆ copy_bbs()

void copy_bbs ( basic_block * bbs,
unsigned n,
basic_block * new_bbs,
edge * edges,
unsigned num_edges,
edge * new_edges,
class loop * base,
basic_block after,
bool update_dominance )
Duplicates N basic blocks stored in array BBS.  Newly created basic blocks
are placed into array NEW_BBS in the same order.  Edges from basic blocks
in BBS are also duplicated and copies of those that lead into BBS are
redirected to appropriate newly created block.  The function assigns bbs
into loops (copy of basic block bb is assigned to bb->loop_father->copy
loop, so this must be set up correctly in advance)

If UPDATE_DOMINANCE is true then this function updates dominators locally
(LOOPS structure that contains the information about dominators is passed
to enable this), otherwise it does not update the dominator information
and it assumed that the caller will do this, perhaps by destroying and
recreating it instead of trying to do an incremental update like this
function does when update_dominance is true.

BASE is the superloop to that basic block belongs; if its header or latch
is copied, we do not set the new blocks as header or latch.

Created copies of N_EDGES edges in array EDGES are stored in array NEW_EDGES,
also in the same order.

Newly created basic blocks are put after the basic block AFTER in the
instruction stream, and the order of the blocks in BBS array is preserved.   

References CDI_DOMINATORS, duplicate_block(), find_edge(), basic_block_def::flags, FOR_EACH_EDGE, get_bb_copy(), get_immediate_dominator(), loop::header, i, loop::latch, basic_block_def::loop_father, NULL, redirect_edge_and_branch_force(), set_immediate_dominator(), and basic_block_def::succs.

Referenced by duplicate_loop_body_to_header_edge(), back_jt_path_registry::duplicate_thread_path(), gimple_duplicate_seme_region(), gimple_duplicate_sese_tail(), and slpeel_tree_duplicate_loop_to_edge_cfg().

◆ create_basic_block() [1/2]

◆ create_basic_block() [2/2]

basic_block create_basic_block ( rtx head,
rtx end,
basic_block after )

References create_basic_block_1(), and end().

◆ create_basic_block_1()

static basic_block create_basic_block_1 ( void * head,
void * end,
basic_block after )
Creates a new basic block just after the basic block AFTER.
HEAD and END are the first and the last statement belonging
to the block.  If both are NULL, an empty block is created.   

References add_to_dominance_info(), CDI_DOMINATORS, CDI_POST_DOMINATORS, cfg_hooks::create_basic_block, dom_info_available_p(), end(), internal_error(), and cfg_hooks::name.

Referenced by create_basic_block(), create_basic_block(), and create_empty_bb().

◆ create_empty_bb()

◆ current_ir_type()

◆ debug() [1/2]

DEBUG_FUNCTION void debug ( basic_block_def & ref)

References dump_bb(), and TDF_NONE.

◆ debug() [2/2]

DEBUG_FUNCTION void debug ( basic_block_def * ptr)

References debug.

◆ debug_flow_info()

DEBUG_FUNCTION void debug_flow_info ( void )
Like above, but dump to stderr.  To be called from debuggers.   

References dump_flow_info(), and TDF_DETAILS.

◆ debug_slim()

static void debug_slim ( basic_block ptr)

◆ delete_basic_block()

◆ dump_bb()

void dump_bb ( FILE * outf,
basic_block bb,
int indent,
dump_flags_t flags )
Print out one basic block BB to file OUTF.  INDENT is printed at the
start of each new line.  FLAGS are the TDF_* flags in dumpfile.h.

This function takes care of the purely graph related information.
The cfg hook for the active representation should dump
representation-specific information.   

References cfg_hooks::dump_bb, dump_bb_info(), fputc(), and TDF_BLOCKS.

Referenced by debug(), debug_bb(), df_dump_region(), dump_basic_block(), dump_flow_info(), dump_function_to_file(), gimple_debug_bb(), is_edge_inconsistent(), is_inconsistent(), print_loops_bb(), and remove_bb().

◆ dump_bb_for_graph()

void dump_bb_for_graph ( pretty_printer * pp,
basic_block bb )
Dumps basic block BB to pretty-printer PP, for use as a label of
a DOT graph record-node.  The implementation of this hook is
expected to write the label to the stream that is attached to PP.
Field separators between instructions are pipe characters printed
verbatim.  Instructions should be written with some characters
escaped, using pp_write_text_as_dot_label_to_stream().   

References basic_block_def::count, cfg_hooks::dump_bb_for_graph, dump_flags, profile_count::initialized_p(), internal_error(), cfg_hooks::name, pp_printf(), pp_write_text_to_stream(), PRId64, TDF_SLIM, and profile_count::to_gcov_type().

Referenced by draw_cfg_node().

◆ dump_flow_info()

void dump_flow_info ( FILE * file,
dump_flags_t flags )

◆ duplicate_block()

basic_block duplicate_block ( basic_block bb,
edge e,
basic_block after,
copy_bb_data * id )
Duplicate basic block BB, place it after AFTER (if non-null) and redirect
edge E to it (if non-null).  Return the new basic block.

If BB contains a returns_twice call, the caller is responsible for recreating
incoming abnormal edges corresponding to the "second return" for the copy.
gimple_can_duplicate_bb_p rejects such blocks, while RTL likes to live

If BB has incoming abnormal edges for some other reason, their destinations
should be tied to label(s) of the original BB and not the copy.   

References add_bb_to_loop(), can_duplicate_block_p(), basic_block_def::count, current_loops, cfg_hooks::duplicate_block, basic_block_def::flags, FOR_EACH_EDGE, gcc_checking_assert, get_loop_copy(), loop::header, internal_error(), loop::latch, basic_block_def::loop_father, loop_outer(), LOOPS_MAY_HAVE_MULTIPLE_LATCHES, loops_state_set(), mark_loop_for_removal(), move_block_after(), cfg_hooks::name, NULL, redirect_edge_and_branch_force(), set_bb_copy(), set_bb_original(), basic_block_def::succs, unchecked_make_edge(), and profile_count::uninitialized().

Referenced by copy_bb(), copy_bbs(), create_block_for_threading(), isolate_path(), maybe_duplicate_computed_goto(), transform_duplicate(), and try_shrink_wrapping().

◆ empty_block_p()

◆ execute_on_growing_pred()

void execute_on_growing_pred ( edge e)
This function is called immediately after edge E is added to the
edge vector E->dest->preds.   

References cfg_hooks::execute_on_growing_pred.

Referenced by redirect_edge_succ(), and unchecked_make_edge().

◆ execute_on_shrinking_pred()

void execute_on_shrinking_pred ( edge e)
This function is called immediately before edge E is removed from
the edge vector E->dest->preds.   

References cfg_hooks::execute_on_shrinking_pred.

Referenced by redirect_edge_succ(), and remove_edge_raw().

◆ extract_cond_bb_edges()

void extract_cond_bb_edges ( basic_block b,
edge * e1,
edge * e2 )
Conditional jumps are represented differently in trees and RTL,
this hook takes a basic block that is known to have a cond jump
at its end and extracts the taken and not taken edges out of it
and store it in E1 and E2 respectively.   

References b, cfg_hooks::extract_cond_bb_edges, and gcc_assert.

◆ flow_call_edges_add()

int flow_call_edges_add ( sbitmap blocks)
Add fake edges to the function exit for any non constant and non noreturn
calls, volatile inline assembly in the bitmap of blocks specified by
BLOCKS or to the whole CFG if BLOCKS is zero.  Return the number of blocks
that were split.

The goal is to expose cases in which entering a basic block does not imply
that all subsequent instructions must be executed.   

References cfg_hooks::flow_call_edges_add, internal_error(), and cfg_hooks::name.

Referenced by branch_prob().

◆ force_nonfallthru()

◆ get_cfg_hooks()

struct cfg_hooks get_cfg_hooks ( void )

References cfg_hooks.

◆ gimple_register_cfg_hooks()

◆ lv_add_condition_to_bb()

void lv_add_condition_to_bb ( basic_block first,
basic_block second,
basic_block new_block,
void * cond )
Conditions in trees and RTL are different so we need
a different handling when we add the condition to the
versioning code.   

References gcc_assert, and cfg_hooks::lv_add_condition_to_bb.

Referenced by lv_adjust_loop_entry_edge().

◆ lv_adjust_loop_header_phi()

void lv_adjust_loop_header_phi ( basic_block first,
basic_block second,
basic_block new_block,
edge e )
Responsible for updating the ssa info (PHI nodes) on the
new condition basic block that guards the versioned loop.   

References cfg_hooks::lv_adjust_loop_header_phi.

Referenced by lv_adjust_loop_entry_edge().

◆ lv_flush_pending_stmts()

void lv_flush_pending_stmts ( edge e)
This is used inside loop versioning when we want to insert
stmts/insns on the edges, which have a different behavior
in tree's and in RTL, so we made a CFG hook.   

References cfg_hooks::flush_pending_stmts.

Referenced by loop_version().

◆ make_forwarder_block()

◆ merge_blocks()

◆ move_block_after()

bool move_block_after ( basic_block bb,
basic_block after )
Moves block BB immediately after block AFTER.  Returns false if the
movement was impossible.   

References internal_error(), cfg_hooks::move_block_after, and cfg_hooks::name.

Referenced by create_preheader(), duplicate_block(), gimple_merge_blocks(), loop_version(), and move_block_to_fn().

◆ predict_edge()

void predict_edge ( edge e,
enum br_predictor predictor,
int probability )

◆ predicted_by_p()

◆ profile_record_account_profile()

void profile_record_account_profile ( profile_record * record)
Work-horse for passes.cc:acount_profile.
Do book-keeping of the CFG for the profile accounting.
Store the counting in RECORD.   

References cfg_hooks::account_profile_record, cfun, FOR_ALL_BB_FN, and gcc_assert.

Referenced by account_profile().

◆ profile_record_check_consistency()

◆ redirect_edge_and_branch()

◆ redirect_edge_and_branch_force()

◆ redirect_edge_succ_nodup()

◆ remove_branch()

void remove_branch ( edge e)
Removes E, by redirecting it to the destination of the other edge going
from its source.  Can_remove_branch_p must be true for E, hence this
operation cannot fail.   

References EDGE_COUNT, EDGE_SUCC, gcc_assert, NULL, and redirect_edge_and_branch().

Referenced by fuse_loops(), and remove_path().

◆ remove_edge()

void remove_edge ( edge e)
Removes edge E from cfg.  Unlike remove_branch, it does not update IL.   

References current_ir_type(), current_loops, IR_GIMPLE, LOOPS_HAVE_MARKED_IRREDUCIBLE_REGIONS, LOOPS_NEED_FIXUP, loops_state_satisfies_p(), loops_state_set(), NULL, redirect_edge_var_map_clear(), remove_edge_raw(), and rescan_loop_exit().

Referenced by clean_up_after_unswitching(), simplify_using_ranges::cleanup_edges_and_switches(), cleanup_empty_eh(), combine_blocks(), cond_move_process_if_block(), convert_if_conditions_to_switch(), dead_or_predicable(), delete_basic_block(), edge_before_returns_twice_call(), eliminate_unnecessary_stmts(), expand_call_inline(), expand_case(), expand_gimple_tailcall(), expand_omp_for_generic(), expand_omp_for_init_counts(), expand_omp_for_init_vars(), expand_omp_for_ordered_loops(), expand_omp_for_static_chunk(), expand_omp_for_static_nochunk(), expand_omp_simd(), expand_omp_target(), expand_omp_taskloop_for_inner(), expand_omp_taskloop_for_outer(), expand_omp_taskreg(), expand_parallel_call(), expand_thunk(), find_bb_boundaries(), find_cond_trap(), tree_switch_conversion::switch_conversion::gen_inbound_check(), gimple_divmod_fixed_value(), gimple_ic(), gimple_mod_pow2(), gimple_stringop_fixed_value(), isolate_path(), local_cprop_pass(), lower_eh_dispatch(), lower_resx(), maybe_cleanup_end_of_block(), merge_blocks(), move_sese_region_to_fn(), noce_convert_multiple_sets(), noce_process_if_block(), one_cprop_pass(), tree_switch_conversion::switch_conversion::prune_bbs(), purge_dead_edges(), purge_dead_tablejump_edges(), redirect_edge_succ_nodup(), remove_ctrl_stmt_and_useless_edges(), remove_edge_and_dominated_blocks(), remove_fake_predecessors(), remove_phi_nodes_and_edges_for_unreachable_block(), simplify_gimple_switch_label_vec(), split_function(), try_combine(), try_redirect_by_replacing_jump(), unloop(), and unsplit_eh().

◆ rtl_register_cfg_hooks()

void rtl_register_cfg_hooks ( void )
Initialization of functions specific to the rtl IR.   

References rtl_cfg_hooks.

Referenced by cfg_layout_finalize(), function_reader::create_function(), and skip_pass().

◆ set_cfg_hooks()

void set_cfg_hooks ( struct cfg_hooks new_cfg_hooks)

◆ split_block() [1/2]

edge split_block ( basic_block bb,
gimple * i )

References i, and split_block_1().

Referenced by branch_fixup(), rt_bb_visited::check(), copy_edges_for_bb(), create_call_for_reduction_1(), create_cond_insert_point(), decompose_multiword_subregs(), tree_switch_conversion::switch_decision_tree::do_jump_if_equal(), tree_switch_conversion::jump_table_cluster::emit(), tree_switch_conversion::switch_decision_tree::emit_cmp_and_jump_insns(), expand_call_inline(), expand_complex_div_wide(), expand_oacc_for(), expand_omp_for_generic(), expand_omp_for_init_counts(), expand_omp_for_init_vars(), expand_omp_for_ordered_loops(), expand_omp_for_static_chunk(), expand_omp_for_static_nochunk(), expand_omp_ordered_sink(), expand_omp_simd(), expand_omp_target(), expand_omp_taskloop_for_outer(), expand_omp_taskreg(), find_bb_boundaries(), fixup_noreturn_call(), tree_switch_conversion::switch_conversion::gen_inbound_check(), gimple_divmod_fixed_value(), gimple_find_sub_bbs(), gimple_flow_call_edges_add(), gimple_ic(), gimple_lower_bitint(), gimple_mod_pow2(), gimple_mod_subtract(), gimple_split_block_before_cond_jump(), gimple_stringop_fixed_value(), gsi_insert_finally_seq_after_call(), tree_switch_conversion::bit_test_cluster::hoist_edge_and_branch_if_true(), hoist_guard(), insert_cond_bb(), insert_trap(), local_cprop_pass(), oacc_entry_exit_single_gang(), omp_sese_split_blocks(), one_cprop_pass(), optimize_mask_stores(), peep2_attempt(), remove_exits_and_undefined_stmts(), rtl_flow_call_edges_add(), rtl_split_block_before_cond_jump(), shrink_wrap_one_built_in_call_with_conds(), simd_clone_adjust(), split_bb_make_tm_edge(), split_function(), try_combine(), try_crossjump_to_edge(), tree_switch_conversion::switch_decision_tree::try_switch_expansion(), ubsan_expand_null_ifn(), ubsan_expand_ptr_ifn(), vect_loop_versioning(), worker_single_copy(), and worker_single_simple().

◆ split_block() [2/2]

edge split_block ( basic_block bb,
rtx i )

References i, and split_block_1().

◆ split_block_1()

static edge split_block_1 ( basic_block bb,
void * i )
Splits basic block BB after the specified instruction I (but at least after
the labels).  If I is NULL, splits just after labels.  The newly created edge
is returned.  The new basic block is created just after the old one.   

References add_bb_to_loop(), CDI_DOMINATORS, basic_block_def::count, current_loops, dom_info_available_p(), basic_block_def::flags, FOR_EACH_EDGE, i, internal_error(), basic_block_def::loop_father, make_single_succ_edge(), cfg_hooks::name, NULL, redirect_immediate_dominators(), set_immediate_dominator(), cfg_hooks::split_block, and basic_block_def::succs.

Referenced by split_block(), split_block(), and split_block_after_labels().

◆ split_block_after_labels()

◆ split_block_before_cond_jump()

basic_block split_block_before_cond_jump ( basic_block bb)
Split a basic block if it ends with a conditional branch and if
the other part of the block is not empty.   

References gcc_assert, and cfg_hooks::split_block_before_cond_jump.

Referenced by transform_to_exit_first_loop_alt().

◆ split_edge()

basic_block split_edge ( edge e)
Splits edge E and returns the newly created basic block.   

References add_bb_to_loop(), profile_probability::always(), CDI_DOMINATORS, basic_block_def::count, count, current_loops, dom_info_available_p(), dom_info_state(), DOM_NO_FAST_QUERY, dominated_by_p(), find_common_loop(), basic_block_def::flags, FOR_EACH_EDGE, get_immediate_dominator(), loop::header, internal_error(), loop::latch, basic_block_def::loop_father, cfg_hooks::name, NULL, rescan_loop_exit(), set_immediate_dominator(), single_pred(), single_pred_edge(), single_succ(), single_succ_edge(), and cfg_hooks::split_edge.

Referenced by analyze_insns_in_loop(), branch_prob(), build_and_add_sum(), commit_one_edge_insertion(), connect_loops(), convert_if_conditions_to_switch(), create_bb_after_loop(), create_empty_if_region_on_edge(), create_empty_loop_on_edge(), create_new_iv(), create_parallel_loop(), create_preheader(), disambiguate_multiple_latches(), do_split_loop_on_cond(), doloop_modify(), tree_switch_conversion::switch_decision_tree::emit_case_nodes(), execute_sm_if_changed(), expand_complex_libcall(), expand_omp_for_generic(), expand_omp_for_static_chunk(), expand_omp_for_static_nochunk(), expand_omp_simd(), expand_phi_nodes(), find_implicit_sets(), fixup_reorder_chain(), force_one_exit_fallthru(), force_single_succ_latches(), gimple_duplicate_sese_tail(), gimple_find_edge_insert_loc(), gimple_gen_ic_func_profiler(), gimple_gen_time_profiler(), gimple_ic(), ifcvt_split_critical_edges(), insert_edge_check_and_trap(), insert_prologue_epilogue_for_components(), loop_version(), lv_adjust_loop_entry_edge(), make_forwarders_with_degenerate_phis(), move_insn_for_shrink_wrap(), move_invariant_reg(), move_sese_in_condition(), remove_forwarder_block_with_phi(), remove_path(), separate_decls_in_region(), shrink_wrap_one_built_in_call_with_conds(), sjlj_emit_function_enter(), slpeel_add_loop_guard(), slpeel_tree_duplicate_loop_to_edge_cfg(), split_critical_edges(), split_edge_and_insert(), split_loop_exit_edge(), fwd_jt_path_registry::thread_through_loop_header(), transform_to_exit_first_loop_alt(), tree_function_versioning(), tree_optimize_tail_calls_1(), tree_transform_and_unroll_loop(), try_shrink_wrapping(), tree_switch_conversion::switch_decision_tree::try_switch_expansion(), unroll_loop_runtime_iterations(), vect_do_peeling(), vect_loop_versioning(), vect_transform_loop(), worker_single_copy(), and worker_single_simple().

◆ tidy_fallthru_edge()

void tidy_fallthru_edge ( edge e)
Try to make the edge fallthru.   

References cfg_hooks::tidy_fallthru_edge.

Referenced by merge_if_block(), tidy_fallthru_edges(), and try_simplify_condjump().

◆ tidy_fallthru_edges()

void tidy_fallthru_edges ( void )
Fix up edges that now fall through, or rather should now fall through
but previously required a jump around now deleted blocks.  Simplify
the search by only examining blocks numerically adjacent, since this
is how they were created.

??? This routine is currently RTL specific.   

References b, BB_END, cfun, CROSSING_JUMP_P, EDGE_COMPLEX, ENTRY_BLOCK_PTR_FOR_FN, EXIT_BLOCK_PTR_FOR_FN, FOR_BB_BETWEEN, JUMP_P, basic_block_def::next_bb, single_succ_edge(), single_succ_p(), cfg_hooks::tidy_fallthru_edge, and tidy_fallthru_edge().

Referenced by delete_unreachable_blocks(), and post_order_compute().

◆ verify_flow_info()

Variable Documentation

◆ cfg_hooks

struct cfg_hooks* cfg_hooks
Hooks for cfg representation specific functions.
   Copyright (C) 2003-2024 Free Software Foundation, Inc.
   Contributed by Sebastian Pop <s.pop@laposte.net>

This file is part of GCC.

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

GCC is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING3.  If not see
Disable warnings about missing quoting in GCC diagnostics.   
A pointer to one of the hooks containers.   

Referenced by get_cfg_hooks().