Functions
void	rtl_register_cfg_hooks ()
void	cfg_layout_rtl_register_cfg_hooks ()
void	gimple_register_cfg_hooks ()
struct cfg_hooks	get_cfg_hooks ()
void	set_cfg_hooks ()
enum ir_type	current_ir_type ()
DEBUG_FUNCTION void	verify_flow_info ()
void	dump_bb ()
DEBUG_FUNCTION void	debug ()
void	dump_bb_for_graph ()
void	dump_flow_info ()
void	debug_flow_info (void)
edge	redirect_edge_and_branch ()
bool	can_remove_branch_p ()
void	remove_branch ()
void	remove_edge ()
edge	redirect_edge_succ_nodup ()
basic_block	redirect_edge_and_branch_force ()
edge	split_block ()
edge	split_block_after_labels ()
bool	move_block_after ()
void	delete_basic_block ()
basic_block	split_edge ()
basic_block	create_basic_block ()
basic_block	create_empty_bb ()
bool	can_merge_blocks_p ()
void	predict_edge ()
bool	predicted_by_p ()
void	merge_blocks ()
edge	make_forwarder_block (basic_block bb, bool(redirect_edge_p)(edge), void(new_bb_cbk)(basic_block))
void	tidy_fallthru_edge ()
void	tidy_fallthru_edges ()
basic_block	force_nonfallthru ()
bool	can_duplicate_block_p ()
basic_block	duplicate_block ()
bool	block_ends_with_call_p ()
bool	block_ends_with_condjump_p ()
int	flow_call_edges_add ()
void	execute_on_growing_pred ()
void	execute_on_shrinking_pred ()
void	lv_flush_pending_stmts ()
bool	cfg_hook_duplicate_loop_to_header_edge (struct loop loop, edge e, unsigned int ndupl, sbitmap wont_exit, edge orig, vec< edge > to_remove, int flags)
void	extract_cond_bb_edges ()
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 ()
void	copy_bbs (basic_block bbs, unsigned n, basic_block new_bbs, edge edges, unsigned num_edges, edge new_edges, struct loop *base, basic_block after, bool update_dominance)
bool	empty_block_p ()
basic_block	split_block_before_cond_jump ()
void	account_profile_record ()

Variables
static struct cfg_hooks *	cfg_hooks

Function Documentation

void account_profile_record ( )

Work-horse for passes.c:check_profile_consistency.
   Do book-keeping of the CFG for the profile consistency checker.
   If AFTER_PASS is 0, do pre-pass accounting, or if AFTER_PASS is 1
   then do post-pass accounting.  Store the counting in RECORD.

References cfg_hooks::account_profile_record, cfun, edge_def::count, basic_block_def::count, basic_block_def::frequency, profile_record::num_mismatched_count_in, profile_record::num_mismatched_count_out, profile_record::num_mismatched_freq_in, profile_record::num_mismatched_freq_out, basic_block_def::preds, edge_def::probability, PROFILE_ABSENT, and basic_block_def::succs.

Referenced by check_profile_consistency().

bool block_ends_with_call_p ( )

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(), fix_up_fall_thru_edges(), is_edge_inconsistent(), and is_inconsistent().

bool block_ends_with_condjump_p ( )

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

bool can_copy_bbs_p ( )

Checks whether all N blocks in BBS array can be copied.

References can_duplicate_block_p(), edge_def::dest, edge_def::flags, and basic_block_def::flags.

Referenced by can_duplicate_loop_p(), duplicate_loop_to_header_edge(), gimple_duplicate_sese_region(), gimple_duplicate_sese_tail(), and slpeel_tree_duplicate_loop_to_edge_cfg().

bool can_duplicate_block_p ( )

Returns true if we can duplicate basic block BB.

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

Referenced by can_copy_bbs_p(), copy_bb_p(), duplicate_block(), duplicate_computed_gotos(), tail_duplicate(), and thread_prologue_and_epilogue_insns().

bool can_merge_blocks_p ( )

Checks whether we may merge blocks BB1 and BB2.

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

Referenced by cleanup_tree_cfg_bb(), combine_blocks(), cond_move_process_if_block(), find_cond_trap(), noce_process_if_block(), and try_optimize_cfg().

bool can_remove_branch_p ( )

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, internal_error(), cfg_hooks::name, edge_def::src, and basic_block_def::succs.

Referenced by remove_path().

bool cfg_hook_duplicate_loop_to_header_edge	(	struct loop *	loop,
		edge	e,
		unsigned int	ndupl,
		sbitmap	wont_exit,
		edge	orig,
		vec< edge > *	to_remove,
		int	flags
	)

Loop versioning uses the duplicate_loop_to_header_edge to create
   a new version of the loop basic-blocks, the parameters here are
   exactly the same as in duplicate_loop_to_header_edge or
   tree_duplicate_loop_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_to_header_edge rather
   than duplicate_loop_to_header_edge when we are in tree mode.

References cfg_hooks::cfg_hook_duplicate_loop_to_header_edge.

Referenced by loop_version().

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

void copy_bbs	(	basic_block *	bbs,
		unsigned	n,
		basic_block *	new_bbs,
		edge *	edges,
		unsigned	num_edges,
		edge *	new_edges,
		struct 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, edge_def::dest, duplicate_block(), basic_block_def::flags, get_bb_copy(), get_immediate_dominator(), loop::header, loop::latch, basic_block_def::loop_father, redirect_edge_and_branch_force(), set_immediate_dominator(), and basic_block_def::succs.

Referenced by duplicate_loop_to_header_edge(), gimple_duplicate_sese_region(), gimple_duplicate_sese_tail(), ipa_uninstrument_transaction(), and slpeel_tree_duplicate_loop_to_edge_cfg().

basic_block create_basic_block ( )

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(), internal_error(), and cfg_hooks::name.

Referenced by begin_move_insn(), cfg_layout_duplicate_bb(), cfg_layout_split_edge(), construct_exit_block(), construct_init_block(), copy_bb(), create_empty_bb(), emit_to_new_bb_before(), expand_gimple_cond(), expand_gimple_tailcall(), expand_thunk(), fix_crossing_conditional_branches(), fix_up_crossing_landing_pad(), force_nonfallthru_and_redirect(), init_lowered_empty_function(), make_blocks(), rtl_split_block(), rtl_split_edge(), sched_create_recovery_block(), split_function(), thread_prologue_and_epilogue_insns(), and unloop_loops().

basic_block create_empty_bb ( )

Creates an empty basic block just after basic block AFTER.

References create_basic_block().

Referenced by build_gimple_cfg(), create_cond_insert_point(), execute_sm_if_changed(), expand_complex_div_wide(), expand_omp_for_generic(), expand_omp_for_init_counts(), expand_omp_sections(), expand_parallel_call(), expand_transaction(), extract_omp_for_update_vars(), factor_computed_gotos(), gimple_duplicate_bb(), gimple_split_block(), gimple_split_edge(), lower_resx(), mf_build_check_statement_for(), move_sese_region_to_fn(), sched_create_empty_bb_1(), and unswitch_loop().

enum ir_type current_ir_type ( void )

Returns current ir type.

References cfg_layout_rtl_cfg_hooks, gimple_cfg_hooks, IR_GIMPLE, IR_RTL_CFGLAYOUT, IR_RTL_CFGRTL, and rtl_cfg_hooks.

Referenced by cleanup_cfg(), delete_unreachable_blocks(), dump_eh_tree(), emit_barrier_after_bb(), find_cond_trap(), find_subloop_latch_edge(), gt_ggc_mx(), gt_pch_nx(), lv_adjust_loop_entry_edge(), mark_all_labels(), remove_edge(), reorder_basic_blocks(), rtl_loop_init(), try_optimize_cfg(), and verify_hot_cold_block_grouping().

DEBUG_FUNCTION void debug ( )

References dump_bb().

DEBUG_FUNCTION void debug_flow_info ( void )

Like above, but dump to stderr.  To be called from debuggers.

References dump_flow_info().

void delete_basic_block ( )

Deletes the basic block BB.

References CDI_DOMINATORS, CDI_POST_DOMINATORS, cfg_hooks::delete_basic_block, delete_from_dominance_info(), dom_info_available_p(), expunge_block(), loop::header, internal_error(), loop::latch, basic_block_def::loop_father, LOOPS_NEED_FIXUP, loops_state_set(), cfg_hooks::name, basic_block_def::preds, remove_bb_from_loops(), remove_edge(), and basic_block_def::succs.

Referenced by combine_blocks(), cond_move_process_if_block(), delete_unreachable_blocks(), delete_unreachable_blocks_update_callgraph(), destroy_loop(), doloop_modify(), eliminate_unnecessary_stmts(), find_cond_trap(), find_if_case_1(), find_if_case_2(), fixup_noreturn_call(), if_region_set_false_region(), noce_process_if_block(), post_order_compute(), prune_bbs(), remove_bbs(), remove_edge_and_dominated_blocks(), remove_forwarder_block(), remove_forwarder_block_with_phi(), replace_block_by(), replace_phi_edge_with_variable(), schedule_ebb(), slpeel_tree_duplicate_loop_to_edge_cfg(), try_crossjump_to_edge(), try_optimize_cfg(), and try_simplify_condjump().

void dump_bb ( )

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

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

void dump_bb_for_graph ( )

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, basic_block_def::frequency, HOST_WIDEST_INT_PRINT_DEC, internal_error(), cfg_hooks::name, pp_printf(), and pp_write_text_to_stream().

Referenced by draw_cfg_node().

void dump_flow_info ( )

Dump the complete CFG to FILE.  FLAGS are the TDF_* flags in dumpfile.h.

References dump_bb().

basic_block duplicate_block ( )

Duplicates basic block BB and redirects edge E to it.  Returns the
   new basic block.  The new basic block is placed after the basic block
   AFTER.

References add_bb_to_loop(), edge_def::aux, can_duplicate_block_p(), copy(), edge_def::count, basic_block_def::count, edge_def::dest, cfg_hooks::duplicate_block, edge_def::flags, basic_block_def::flags, basic_block_def::frequency, get_loop_copy(), loop::header, internal_error(), loop::latch, basic_block_def::loop_father, loop_outer(), LOOPS_MAY_HAVE_MULTIPLE_LATCHES, LOOPS_NEED_FIXUP, loops_state_set(), move_block_after(), cfg_hooks::name, edge_def::probability, redirect_edge_and_branch_force(), set_bb_copy(), set_bb_original(), basic_block_def::succs, and unchecked_make_edge().

Referenced by copy_bb(), copy_bbs(), create_block_for_threading(), duplicate_computed_gotos(), and tail_duplicate().

bool empty_block_p ( )

Return true if BB contains only labels or non-executable
   instructions

References cfg_hooks::empty_block_p.

Referenced by allow_ip_end_pos_p(), check_all_empty_except_final(), conditional_replacement(), determine_iv_cost(), if_convertible_bb_p(), minmax_replacement(), slpeel_can_duplicate_loop_p(), statement_sink_location(), thread_through_loop_header(), and vect_analyze_loop_form().

void execute_on_growing_pred ( )

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

void execute_on_shrinking_pred ( )

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

void extract_cond_bb_edges ( )

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 cfg_hooks::extract_cond_bb_edges.

Referenced by loop_version().

int flow_call_edges_add ( )

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

basic_block force_nonfallthru ( )

Edge E is assumed to be fallthru edge.  Emit needed jump instruction
   (and possibly create new basic block) to make edge non-fallthru.
   Return newly created BB or NULL if none.

References add_bb_to_loop(), CDI_DOMINATORS, dom_info_available_p(), find_common_loop(), cfg_hooks::force_nonfallthru, internal_error(), cfg_hooks::name, rescan_loop_exit(), set_immediate_dominator(), single_pred(), single_succ(), and edge_def::src.

Referenced by emit_to_new_bb_before(), fix_up_fall_thru_edges(), fixup_reorder_chain(), merge_blocks_move(), and rtl_split_edge().

struct cfg_hooks get_cfg_hooks ( void )

read

References cfg_hooks.

void gimple_register_cfg_hooks ( void )

Initialization of functions specific to the tree IR.

References gimple_cfg_hooks.

Referenced by analyze_function(), build_gimple_cfg(), cgraph_add_new_function(), cgraph_process_new_functions(), copy_cfg_body(), expand_function(), init_lowered_empty_function(), initialize_cfun(), input_function(), ipa_passes(), and optimize_inline_calls().

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 cfg_hooks::lv_add_condition_to_bb.

Referenced by lv_adjust_loop_entry_edge().

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

void lv_flush_pending_stmts ( )

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

edge make_forwarder_block	(	basic_block	bb,
		bool(*)(edge)	redirect_edge_p,
		void(*)(basic_block)	new_bb_cbk
	)

Split BB into entry part and the rest (the rest is the newly created block).
   Redirect those edges for that REDIRECT_EDGE_P returns true to the entry
   part.  Returns the edge connecting the entry part to the rest.

References add_bb_to_loop(), CDI_DOMINATORS, edge_def::count, basic_block_def::count, edge_def::dest, dom_info_available_p(), ei_next(), ei_safe_edge(), find_common_loop(), find_edge(), basic_block_def::frequency, loop::header, internal_error(), iterate_fix_dominators(), loop::latch, basic_block_def::loop_father, loop_outer(), cfg_hooks::make_forwarder_block, cfg_hooks::name, basic_block_def::preds, redirect_edge_and_branch_force(), remove_bb_from_loops(), split_block_after_labels(), and edge_def::src.

Referenced by create_preheader(), create_single_exit_edge(), form_subloop(), merge_latch_edges(), and thread_through_loop_header().

void merge_blocks ( )

Merges basic block B into basic block A.

References add_bb_to_loop(), CDI_DOMINATORS, CDI_POST_DOMINATORS, delete_from_dominance_info(), edge_def::dest, dom_info_available_p(), expunge_block(), basic_block_def::flags, loop::header, internal_error(), loop::latch, basic_block_def::loop_father, LOOPS_NEED_FIXUP, loops_state_set(), cfg_hooks::merge_blocks, cfg_hooks::name, basic_block_def::preds, redirect_immediate_dominators(), remove_bb_from_loops(), remove_edge(), rescan_loop_exit(), edge_def::src, and basic_block_def::succs.

Referenced by cleanup_tree_cfg_bb(), combine_blocks(), cond_move_process_if_block(), find_cond_trap(), merge_blocks_move(), merge_blocks_move_predecessor_nojumps(), merge_blocks_move_successor_nojumps(), merge_if_block(), noce_process_if_block(), and try_optimize_cfg().

bool move_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().

void predict_edge ( )

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

Referenced by predict_edge_def(), predict_iv_comparison(), and predict_loops().

bool predicted_by_p ( )

References internal_error(), cfg_hooks::name, cfg_hooks::predict_edge, and cfg_hooks::predicted_by_p.

Referenced by predict_iv_comparison(), predict_loops(), and tree_estimate_probability_bb().

edge redirect_edge_and_branch ( )

Redirect edge E to the given basic block DEST and update underlying program
   representation.  Returns edge representing redirected branch (that may not
   be equivalent to E in the case of duplicate edges being removed) or NULL
   if edge is not easily redirectable for whatever reason.

References internal_error(), cfg_hooks::name, cfg_hooks::redirect_edge_and_branch, and rescan_loop_exit().

Referenced by combine_blocks(), create_parallel_loop(), eliminate_tail_call(), expand_omp_for_static_chunk(), fixup_reorder_chain(), forward_edge_to_pdom(), gimple_duplicate_sese_region(), gimple_duplicate_sese_tail(), gimple_split_edge(), remove_branch(), remove_forwarder_block(), remove_forwarder_block_with_phi(), replace_block_by(), rtl_redirect_edge_and_branch_force(), rtl_split_edge(), split_function(), ssa_fix_duplicate_block_edges(), ssa_redirect_edges(), thread_single_edge(), and try_forward_edges().

basic_block redirect_edge_and_branch_force ( )

Redirect the edge E to basic block DEST even if it requires creating
   of a new basic block; then it returns the newly created basic block.
   Aborts when redirection is impossible.

References add_bb_to_loop(), CDI_DOMINATORS, dom_info_available_p(), find_common_loop(), find_edge(), internal_error(), cfg_hooks::name, cfg_hooks::redirect_edge_and_branch_force, rescan_loop_exit(), set_immediate_dominator(), single_pred(), single_succ(), and edge_def::src.

Referenced by add_test(), bypass_block(), cfg_layout_split_edge(), cond_move_process_if_block(), copy_bbs(), doloop_modify(), dup_block_and_redirect(), duplicate_block(), duplicate_loop_to_header_edge(), find_if_case_1(), force_one_exit_fallthru(), loop_redirect_edge(), make_forwarder_block(), noce_process_if_block(), slpeel_tree_duplicate_loop_to_edge_cfg(), thread_prologue_and_epilogue_insns(), try_crossjump_to_edge(), and try_forward_edges().

edge redirect_edge_succ_nodup ( )

Like redirect_edge_succ but avoid possible duplicate edge.

References edge_def::count, find_edge(), edge_def::flags, edge_def::probability, redirect_edge_succ(), redirect_edge_var_map_dup(), remove_edge(), and edge_def::src.

void remove_branch ( )

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_def::dest, edge_def::flags, redirect_edge_and_branch(), edge_def::src, and basic_block_def::succs.

Referenced by remove_path().

void remove_edge ( )

Removes edge E from cfg.  Unlike remove_branch, it does not update IL.

References current_ir_type(), IR_GIMPLE, redirect_edge_var_map_clear(), remove_edge_raw(), and rescan_loop_exit().

Referenced by cleanup_empty_eh(), combine_blocks(), cond_move_process_if_block(), dead_or_predicable(), delete_basic_block(), execute_vrp(), expand_call_inline(), expand_gimple_tailcall(), expand_omp_for_generic(), expand_omp_simd(), expand_parallel_call(), expand_thunk(), find_bb_boundaries(), find_cond_trap(), gen_inbound_check(), gimple_divmod_fixed_value(), gimple_expand_cfg(), gimple_ic(), gimple_mod_pow2(), gimple_stringop_fixed_value(), lower_eh_dispatch(), lower_resx(), maybe_cleanup_end_of_block(), merge_blocks(), move_sese_region_to_fn(), noce_process_if_block(), propagate_rhs_into_lhs(), prune_bbs(), purge_dead_edges(), purge_dead_tablejump_edges(), redirect_edge_succ_nodup(), remove_ctrl_stmt_and_useless_edges(), remove_dead_stmt(), remove_edge_and_dominated_blocks(), remove_fake_predecessors(), remove_phi_nodes_and_edges_for_unreachable_block(), simplify_gimple_switch_label_vec(), split_function(), try_redirect_by_replacing_jump(), unloop(), and unsplit_eh().

void rtl_register_cfg_hooks ( void )

Initialization of functions specific to the rtl IR.

References rtl_cfg_hooks.

Referenced by cfg_layout_finalize(), and gimple_expand_cfg().

void set_cfg_hooks ( )

edge split_block ( )

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, basic_block_def::discriminator, dom_info_available_p(), edge_def::flags, basic_block_def::flags, basic_block_def::frequency, internal_error(), loop::latch, basic_block_def::loop_father, make_single_succ_edge(), cfg_hooks::name, redirect_immediate_dominators(), set_immediate_dominator(), and cfg_hooks::split_block.

Referenced by copy_edges_for_bb(), create_call_for_reduction_1(), create_cond_insert_point(), create_pre_exit(), decompose_multiword_subregs(), expand_call_inline(), expand_complex_div_wide(), expand_omp_for_generic(), expand_omp_for_init_counts(), expand_omp_for_static_chunk(), expand_omp_for_static_nochunk(), expand_omp_simd(), expand_omp_taskreg(), expand_parallel_call(), find_bb_boundaries(), fixup_fallthru_exit_predecessor(), fixup_noreturn_call(), gen_inbound_check(), gimple_divmod_fixed_value(), gimple_flow_call_edges_add(), gimple_ic(), gimple_mod_pow2(), gimple_mod_subtract(), gimple_split_block_before_cond_jump(), gimple_stringop_fixed_value(), hoist_edge_and_branch_if_true(), mf_build_check_statement_for(), peep2_attempt(), rtl_flow_call_edges_add(), rtl_split_block_before_cond_jump(), sched_split_block_1(), shrink_wrap_one_built_in_call(), split_bb_make_tm_edge(), split_block_after_labels(), split_function(), split_pbb(), split_region_for_bb(), thread_prologue_and_epilogue_insns(), and try_crossjump_to_edge().

edge split_block_after_labels ( )

Splits block BB just after labels.  The newly created edge is returned.

References split_block().

Referenced by branch_prob(), canonicalize_loop_closed_ssa(), create_empty_loop_on_edge(), create_single_entry_edge(), execute_sm_if_changed(), ipa_tm_insert_irr_call(), make_forwarder_block(), mf_build_check_statement_for(), split_region_for_bb(), and transform_to_exit_first_loop().

basic_block split_block_before_cond_jump ( )

Split a basic block if it ends with a conditional branch and if
   the other part of the block is not empty.

References cfg_hooks::split_block_before_cond_jump.

basic_block split_edge ( )

Splits edge E and returns the newly created basic block.

References add_bb_to_loop(), CDI_DOMINATORS, count, edge_def::count, basic_block_def::count, edge_def::dest, dom_info_available_p(), dom_info_state(), DOM_NO_FAST_QUERY, dominated_by_p(), find_common_loop(), edge_def::flags, basic_block_def::flags, basic_block_def::frequency, get_immediate_dominator(), loop::header, internal_error(), loop::latch, basic_block_def::loop_father, cfg_hooks::name, edge_def::probability, rescan_loop_exit(), set_immediate_dominator(), single_pred(), single_pred_edge(), single_succ(), single_succ_edge(), cfg_hooks::split_edge, and edge_def::src.

Referenced by analyze_insns_in_loop(), begin_move_insn(), branch_prob(), canon_loop(), canonicalize_loop_closed_ssa(), commit_one_edge_insertion(), copy_bb_and_scalar_dependences(), copy_loop_headers(), create_add_on_incoming_edge(), create_bb_after_loop(), create_empty_if_region_on_edge(), create_empty_loop_on_edge(), create_parallel_loop(), create_pre_exit(), disambiguate_multiple_latches(), doloop_modify(), emit_case_bit_tests(), emit_return_for_exit(), execute_sm_if_changed(), 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_ic(), loop_version(), lv_adjust_loop_entry_edge(), move_sese_in_condition(), optimize_mode_switching(), remove_forwarder_block_with_phi(), remove_path(), rewrite_cross_bb_scalar_deps_out_of_ssa(), separate_decls_in_region(), set_prologue_iterations(), slpeel_tree_duplicate_loop_to_edge_cfg(), slpeel_tree_peel_loop_to_edge(), slpeel_update_phi_nodes_for_guard1(), slpeel_update_phi_nodes_for_guard2(), split_critical_edges(), split_edge_and_insert(), split_loop_exit_edge(), thread_through_loop_header(), translate_clast_assignment(), translate_clast_for_loop(), tree_function_versioning(), tree_optimize_tail_calls_1(), tree_transform_and_unroll_loop(), unroll_loop_runtime_iterations(), unswitch_loop(), vect_loop_versioning(), and vect_transform_loop().

void tidy_fallthru_edge ( )

Try to make the edge fallthru.

References cfg_hooks::tidy_fallthru_edge.

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

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 edge_def::dest, find_reg_note(), edge_def::flags, basic_block_def::next_bb, basic_block_def::prev_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().

DEBUG_FUNCTION void verify_flow_info ( void )

Verify the CFG consistency.

   Currently it does following: checks edge and basic block list correctness
   and calls into IL dependent checking then.

References edge_def::count, basic_block_def::count, edge_def::dest, edge_def::dest_idx, dump_edge_info(), error(), edge_def::flags, free(), basic_block_def::frequency, basic_block_def::index, edge_iterator::index, internal_error(), basic_block_def::loop_father, basic_block_def::next_bb, basic_block_def::preds, basic_block_def::prev_bb, edge_def::probability, edge_def::src, basic_block_def::succs, timevar_pop(), timevar_push(), and cfg_hooks::verify_flow_info.

Referenced by cfg_layout_finalize(), cleanup_tree_cfg_noloop(), commit_edge_insertions(), execute_function_todo(), expand_thunk(), gimple_expand_cfg(), gimple_flow_call_edges_add(), if_convert(), move_loop_invariants(), rtl_flow_call_edges_add(), split_all_insns(), tree_transform_and_unroll_loop(), and try_optimize_cfg().

Variable Documentation

struct cfg_hooks* cfg_hooks

static

@verbatim Hooks for cfg representation specific functions.

This file is part of GCC.

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

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

You should have received a copy of the GNU General Public License along with GCC; see the file COPYING3. If not see http://www.gnu.org/licenses/.

A pointer to one of the hooks containers.

Referenced by get_cfg_hooks().

Functions

Variables

Function Documentation

Variable Documentation