GCC Middle and Back End API Reference
cfgloop.h File Reference
#include "cfgloopmanip.h"
Include dependency graph for cfgloop.h:

Go to the source code of this file.

Data Structures

struct  lpt_decision
class  nb_iter_bound
struct  loop_exit
struct  loop_exit_hasher
struct  control_iv
class  loop
struct  loops
class  rtx_iv
class  niter_desc
class  loops_list
class  loops_list::Iter< T >
struct  target_cfgloop


#define LOOP_C_INFINITE   (1 << 0)
#define LOOP_C_FINITE   (1 << 1)
#define this_target_cfgloop   (&default_target_cfgloop)
#define target_avail_regs    (this_target_cfgloop->x_target_avail_regs)
#define target_clobbered_regs    (this_target_cfgloop->x_target_clobbered_regs)
#define target_res_regs    (this_target_cfgloop->x_target_res_regs)
#define target_reg_cost    (this_target_cfgloop->x_target_reg_cost)
#define target_spill_cost    (this_target_cfgloop->x_target_spill_cost)


typedef generic_wide_int< fixed_wide_int_storage< WIDE_INT_MAX_INL_PRECISION > > bound_wide_int
typedef class looploop_p


enum  loop_estimation { EST_NOT_COMPUTED , EST_AVAILABLE , EST_LAST }
enum  {
enum  li_flags { LI_INCLUDE_ROOT = 1 , LI_FROM_INNERMOST = 2 , LI_ONLY_INNERMOST = 4 }
enum  { UAP_UNROLL = 1 , UAP_UNROLL_ALL = 2 }


void loop_constraint_set (class loop *loop, unsigned c)
void loop_constraint_clear (class loop *loop, unsigned c)
bool loop_constraint_set_p (class loop *loop, unsigned c)
bool bb_loop_header_p (basic_block)
void init_loops_structure (struct function *, struct loops *, unsigned)
struct loopsflow_loops_find (struct loops *)
void disambiguate_loops_with_multiple_latches (void)
void flow_loops_free (struct loops *)
void flow_loops_dump (FILE *, void(*)(const class loop *, FILE *, int), int)
void flow_loop_dump (const class loop *, FILE *, void(*)(const class loop *, FILE *, int), int)
class loopalloc_loop (void)
void flow_loop_free (class loop *)
int flow_loop_nodes_find (basic_block, class loop *)
unsigned fix_loop_structure (bitmap changed_bbs)
bool mark_irreducible_loops (void)
void release_recorded_exits (function *)
void record_loop_exits (void)
void rescan_loop_exit (edge, bool, bool)
void sort_sibling_loops (function *)
void flow_loop_tree_node_add (class loop *, class loop *, class loop *=NULL)
void flow_loop_tree_node_remove (class loop *)
bool flow_loop_nested_p (const class loop *, const class loop *)
bool flow_bb_inside_loop_p (const class loop *, const_basic_block)
class loopfind_common_loop (class loop *, class loop *)
class loopsuperloop_at_depth (class loop *, unsigned)
int num_loop_insns (const class loop *)
int average_num_loop_insns (const class loop *)
unsigned get_loop_level (const class loop *)
bool loop_exit_edge_p (const class loop *, const_edge)
bool loop_exits_to_bb_p (class loop *, basic_block)
bool loop_exits_from_bb_p (class loop *, basic_block)
void mark_loop_exit_edges (void)
dump_user_location_t get_loop_location (class loop *loop)
basic_blockget_loop_body (const class loop *)
unsigned get_loop_body_with_size (const class loop *, basic_block *, unsigned)
basic_blockget_loop_body_in_dom_order (const class loop *)
basic_blockget_loop_body_in_bfs_order (const class loop *)
basic_blockget_loop_body_in_custom_order (const class loop *, int(*)(const void *, const void *))
basic_blockget_loop_body_in_custom_order (const class loop *, void *, int(*)(const void *, const void *, void *))
auto_vec< edgeget_loop_exit_edges (const class loop *, basic_block *=NULL)
edge single_exit (const class loop *)
edge single_likely_exit (class loop *loop, const vec< edge > &)
unsigned num_loop_branches (const class loop *)
edge loop_preheader_edge (const class loop *)
edge loop_latch_edge (const class loop *)
void add_bb_to_loop (basic_block, class loop *)
void remove_bb_from_loops (basic_block)
void cancel_loop_tree (class loop *)
void delete_loop (class loop *)
void verify_loop_structure (void)
bool just_once_each_iteration_p (const class loop *, const_basic_block)
gcov_type expected_loop_iterations_unbounded (const class loop *, bool *read_profile_p=NULL)
bool expected_loop_iterations_by_profile (const class loop *loop, sreal *ret, bool *reliable=NULL)
bool maybe_flat_loop_profile (const class loop *)
unsigned expected_loop_iterations (class loop *)
rtx doloop_condition_get (rtx_insn *)
void mark_loop_for_removal (loop_p)
void print_loop_info (FILE *file, const class loop *loop, const char *)
void iv_analysis_loop_init (class loop *)
bool iv_analyze (rtx_insn *, scalar_int_mode, rtx, class rtx_iv *)
bool iv_analyze_result (rtx_insn *, rtx, class rtx_iv *)
bool iv_analyze_expr (rtx_insn *, scalar_int_mode, rtx, class rtx_iv *)
rtx get_iv_value (class rtx_iv *, rtx)
bool biv_p (rtx_insn *, scalar_int_mode, rtx)
void iv_analysis_done (void)
class niter_descget_simple_loop_desc (class loop *loop)
void free_simple_loop_desc (class loop *loop)
class niter_descsimple_loop_desc (class loop *loop)
class loopget_loop (struct function *fn, unsigned num)
unsigned loop_depth (const class loop *loop)
class looploop_outer (const class loop *loop)
bool loop_has_exit_edges (const class loop *loop)
vec< loop_p, va_gc > * get_loops (struct function *fn)
unsigned number_of_loops (struct function *fn)
bool loops_state_satisfies_p (function *fn, unsigned flags)
bool loops_state_satisfies_p (unsigned flags)
void loops_state_set (function *fn, unsigned flags)
void loops_state_set (unsigned flags)
void loops_state_clear (function *fn, unsigned flags)
void loops_state_clear (unsigned flags)
void checking_verify_loop_structure (void)
template<typename T >
constexpr const Tas_const (T &t)
unsigned estimate_reg_pressure_cost (unsigned, unsigned, bool, bool)
void init_set_costs (void)
void loop_optimizer_init (unsigned)
void loop_optimizer_finalize (function *, bool=false)
void loop_optimizer_finalize ()
void doloop_optimize_loops (void)
void move_loop_invariants (void)
auto_vec< basic_blockget_loop_hot_path (const class loop *loop)
class looploop_outermost (class loop *loop)
void record_niter_bound (class loop *, const widest_int &, bool, bool)
HOST_WIDE_INT get_estimated_loop_iterations_int (class loop *)
HOST_WIDE_INT get_max_loop_iterations_int (const class loop *)
HOST_WIDE_INT get_likely_max_loop_iterations_int (class loop *)
bool get_estimated_loop_iterations (class loop *loop, widest_int *nit)
bool get_max_loop_iterations (const class loop *loop, widest_int *nit)
bool get_likely_max_loop_iterations (class loop *loop, widest_int *nit)
int bb_loop_depth (const_basic_block)
edge single_dom_exit (class loop *)
profile_count loop_count_in (const class loop *loop)
widest_int gcov_type_to_wide_int (gcov_type val)


struct target_cfgloop default_target_cfgloop

Macro Definition Documentation



#define LOOP_C_FINITE   (1 << 1)
Set if the loop is known to be finite without any assumptions.   

Referenced by number_of_iterations_exit_assumptions(), try_vectorize_loop_1(), vect_analyze_loop(), vect_free_loop_info_assumptions(), and vect_loop_versioning().


#define LOOP_C_INFINITE   (1 << 0)
Set if the loop is known to be infinite.   

Referenced by number_of_iterations_exit_assumptions(), and vect_do_peeling().


Definition cfgloop.h:309
Definition cfgloop.h:311
Definition cfgloop.h:310

Referenced by analyze_function_body(), execute_ranger_vrp(), perform_tree_ssa_dce(), report_predictor_hitrates(), rtl_loop_init(), scev_initialize(), and split_paths().

◆ target_avail_regs

#define target_avail_regs    (this_target_cfgloop->x_target_avail_regs)

◆ target_clobbered_regs

#define target_clobbered_regs    (this_target_cfgloop->x_target_clobbered_regs)

◆ target_reg_cost

#define target_reg_cost    (this_target_cfgloop->x_target_reg_cost)

◆ target_res_regs

#define target_res_regs    (this_target_cfgloop->x_target_res_regs)

◆ target_spill_cost

◆ this_target_cfgloop

#define this_target_cfgloop   (&default_target_cfgloop)

Typedef Documentation

◆ bound_wide_int

◆ loop_p

typedef class loop* loop_p

Enumeration Type Documentation

◆ anonymous enum

anonymous enum
Flags for state of loop structure.   

◆ anonymous enum

anonymous enum
Optimization passes.   

◆ iv_extend_code

The type of extend applied to an IV.   

◆ li_flags

enum li_flags
Loop iterators.   
Flags for loop iteration.   

◆ loop_estimation

An integer estimation of the number of iterations.  Estimate_state
describes what is the state of the estimation.   

◆ lpt_dec

enum lpt_dec
Natural loop functions
   Copyright (C) 1987-2024 Free Software Foundation, Inc.

This file is part of GCC.

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

GCC is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or
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
Structure to hold decision about unrolling/peeling.   

Function Documentation

◆ add_bb_to_loop()

◆ alloc_loop()

◆ as_const()

template<typename T >
const T & as_const ( T & t)
Provide the functionality of std::as_const to support range-based for
to use const iterator.  (We can't use std::as_const itself because it's
a C++17 feature.)   

◆ average_num_loop_insns()

int average_num_loop_insns ( const class loop * loop)
Counts number of insns executed on average per iteration LOOP.   

References basic_block_def::count, FOR_BB_INSNS, free(), get_loop_body(), loop::header, i, loop::ninsns, NONDEBUG_INSN_P, loop::num_nodes, and profile_count::to_sreal_scale().

Referenced by decide_unrolling().

◆ bb_loop_depth()

◆ bb_loop_header_p()

◆ biv_p()

bool biv_p ( rtx_insn * insn,
scalar_int_mode mode,
rtx reg )
Checks whether definition of register REG in INSN is a basic induction
variable.  MODE is the mode of REG.

IV analysis must have been initialized (via a call to
iv_analysis_loop_init) for this function to produce a result.   

References const0_rtx, df_find_def(), gcc_assert, iv_analyze_biv(), latch_dominating_def(), rtx_iv::mode, NULL, simple_reg_p(), and iv::step.

Referenced by analyze_iv_to_split_insn().

◆ cancel_loop_tree()

void cancel_loop_tree ( class loop * loop)
Cancels LOOP and all its subloops.   

References cancel_loop(), cancel_loop_tree(), and loop::inner.

Referenced by cancel_loop_tree(), destroy_loop(), and remove_path().

◆ checking_verify_loop_structure()

void checking_verify_loop_structure ( void )

◆ delete_loop()

void delete_loop ( class loop * loop)
Removes LOOP from structures and frees its data.   

References current_loops, flow_loop_free(), flow_loop_tree_node_remove(), NULL, and loop::num.

Referenced by cancel_loop(), fuse_loops(), and unloop().

◆ disambiguate_loops_with_multiple_latches()

void disambiguate_loops_with_multiple_latches ( void )
Split loops with multiple latch edges.   

References cfun, disambiguate_multiple_latches(), and loop::latch.

Referenced by apply_loop_flags().

◆ doloop_condition_get()

rtx doloop_condition_get ( rtx_insn * doloop_pat)
Perform doloop optimizations
   Copyright (C) 2004-2024 Free Software Foundation, Inc.
   Based on code by Michael P. Hayes (m.hayes@elec.canterbury.ac.nz)

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

GCC is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or
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
This module is used to modify loops with a determinable number of
iterations to use special low-overhead looping instructions.

It first validates whether the loop is well behaved and has a
determinable number of iterations (either at compile or run-time).
It then modifies the loop to use a low-overhead looping pattern as

1. A pseudo register is allocated as the loop iteration counter.

2. The number of loop iterations is calculated and is stored
   in the loop counter.

3. At the end of the loop, the jump insn is replaced by the
   doloop_end pattern.  The compare must remain because it might be
   used elsewhere.  If the loop-variable or condition register are
   used elsewhere, they will be eliminated by flow.

4. An optional doloop_begin pattern is inserted at the top of the

TODO The optimization should only performed when either the biv used for exit
condition is unused at all except for the exit test, or if we do not have to
change its value, since otherwise we have to add a new induction variable,
which usually will not pay up (unless the cost of the doloop pattern is
somehow extremely lower than the cost of compare & jump, or unless the bct
register cannot be used for anything else but doloop -- ??? detect these
Return the loop termination condition for PATTERN or zero
if it is not a decrement and branch jump insn.   

References const0_rtx, const1_rtx, constm1_rtx, GEN_INT, GET_CODE, INSN_P, NULL_RTX, PATTERN(), pc_rtx, prev_nondebug_insn(), REG_P, SET, SET_DEST, SET_SRC, XEXP, and XVECEXP.

Referenced by doloop_optimize().

◆ doloop_optimize_loops()

void doloop_optimize_loops ( void )
This is the main entry point.  Process all loops using doloop_optimize.   

References cfun, checking_verify_loop_structure(), df_live, df_live_add_problem(), df_live_set_all_dirty(), df_remove_problem(), doloop_optimize(), and iv_analysis_done().

◆ estimate_reg_pressure_cost()

unsigned estimate_reg_pressure_cost ( unsigned n_new,
unsigned n_old,
bool speed,
bool call_p )
Register pressure estimation for induction variable optimizations & loop
invariant motion.   
Estimates cost of increased register pressure caused by making N_NEW new
registers live around the loop.  N_OLD is the number of registers live
around the loop.  If CALL_P is true, also take into account that
call-used registers may be clobbered in the loop body, reducing the
number of available registers before we spill.   

References cfun, IRA_REGION_ALL, IRA_REGION_MIXED, number_of_loops(), target_avail_regs, target_clobbered_regs, target_reg_cost, target_res_regs, and target_spill_cost.

Referenced by gain_for_invariant().

◆ expected_loop_iterations()

unsigned expected_loop_iterations ( class loop * loop)
Returns expected number of LOOP iterations.  The returned value is bounded

References expected_loop_iterations_unbounded(), and REG_BR_PROB_BASE.

Referenced by determine_loop_nest_reuse().

◆ expected_loop_iterations_by_profile()

bool expected_loop_iterations_by_profile ( const class loop * loop,
sreal * ret,
bool * reliable )
Return true if BB profile can be used to determine the expected number of
iterations (that is number of executions of latch edge(s) for each
entry of the loop.  If this is the case initialize RET with the number
of iterations.

RELIABLE is set if profile indiates that the returned value should be
realistic estimate.  (This is the case if we read profile and did not
messed it up yet and not the case of guessed profiles.)

This function uses only CFG profile.  We track more reliable info in
loop_info structure and for loop optimization heuristics more relevant
is get_estimated_loop_iterations API.   

References basic_block_def::count, profile_count::differs_from_p(), dump_file, dump_flags, loop::header, profile_count::initialized_p(), loop_count_in(), profile_count::nonzero_p(), loop::num, profile_count::reliable_p(), and TDF_DETAILS.

Referenced by branch_prob(), estimate_numbers_of_iterations(), expected_loop_iterations_unbounded(), get_estimated_loop_iterations(), maybe_flat_loop_profile(), print_loop_info(), and scale_loop_profile().

◆ expected_loop_iterations_unbounded()

gcov_type expected_loop_iterations_unbounded ( const class loop * loop,
bool * read_profile_p )
Returns expected number of iterations of LOOP, according to
measured or guessed profile.

This functions attempts to return "sane" value even if profile
information is not good enough to derive osmething.   

References expected_loop_iterations_by_profile(), get_max_loop_iterations_int(), and sreal::to_nearest_int().

Referenced by expected_loop_iterations().

◆ find_common_loop()

◆ fix_loop_structure()

unsigned fix_loop_structure ( bitmap changed_bbs)
The structure of loops might have changed.  Some loops might get removed
(and their headers and latches were set to NULL), loop exists might get
removed (thus the loop nesting may be wrong), and some blocks and edges
were changed (so the information about bb --> loop mapping does not have
to be correct).  But still for the remaining loops the header dominates
the latch, and loops did not get new subloops (new loops might possibly
get created, but we are not interested in them).  Fix up the mess.

If CHANGED_BBS is not NULL, basic blocks whose loop depth has changed are
marked in it.

Returns the number of new discovered plus the number of removed loops.   

References apply_loop_flags(), basic_block_def::aux, BASIC_BLOCK_FOR_FN, basic_block_info_for_fn, bb_loop_header_p(), bitmap_set_bit, CDI_DOMINATORS, cfun, checking_verify_loop_structure(), current_loops, dom_info_state(), DOM_OK, dump_file, dump_flags, flow_loop_free(), flow_loop_tree_node_add(), flow_loop_tree_node_remove(), flow_loops_find(), FOR_EACH_BB_FN, FOR_EACH_VEC_ELT, loop::former_header, gcc_assert, get_loops(), loop::header, i, basic_block_def::index, loop::inner, LI_FROM_INNERMOST, loop_depth(), basic_block_def::loop_father, loop_outer(), LOOPS_HAVE_RECORDED_EXITS, LOOPS_NEED_FIXUP, loops_state_clear(), loops_state_satisfies_p(), NULL, loop::num, number_of_loops(), release_recorded_exits(), scev_initialized_p(), scev_reset_htab(), TDF_DETAILS, timevar_pop(), and timevar_push().

Referenced by cleanup_cfg(), loop_optimizer_init(), repair_loop_structures(), tree_function_versioning(), and unroll_loops().

◆ flow_bb_inside_loop_p()

bool flow_bb_inside_loop_p ( const class loop * loop,
const_basic_block bb )
Return nonzero if basic block BB belongs to LOOP.   

References cfun, ENTRY_BLOCK_PTR_FOR_FN, EXIT_BLOCK_PTR_FOR_FN, flow_loop_nested_p(), and basic_block_def::loop_father.

Referenced by add_exit_phi(), add_to_dst_predicate_list(), add_to_predicate_list(), analyze_evolution_in_loop(), loop_cand::analyze_iloop_reduction_var(), analyze_initial_condition(), loop_cand::analyze_oloop_reduction_var(), analyze_scalar_evolution_1(), base_names_in_chain_on(), bb_in_loop_p(), can_move_invariant_reg(), chain_of_csts_start(), check_exit_phi(), check_loop_closed_ssa_def(), check_reduction_path(), classify_builtin_st(), compute_access_stride(), compute_added_num_insns(), create_rdg_cd_edges(), duplicate_loop_body_to_header_edge(), rpo_elim::eliminate_avail(), eliminate_dom_walker::eliminate_stmt(), evaluate_bbs(), expr_invariant_in_loop_p(), fill_always_executed_in_1(), fill_sons_in_loop(), final_range_test_p(), find_exits(), find_interesting_uses(), find_inv_vars_cb(), find_loop_guard(), find_simple_exit(), find_subloop_latch_edge_by_ivs(), find_unswitching_predicates_for_bb(), find_uses_to_rename_use(), find_vdef_in_loop(), flow_loops_find(), scev_dfs::follow_ssa_edge_inner_loop_phi(), for_all_locs_in_loop(), get_cond_invariant_branch(), get_control_equiv_head_block(), get_iv(), get_loop_body_in_bfs_order(), get_loop_exit_edges(), hoist_defs_of_uses(), hoist_guard(), init_loop_unswitch_info(), inner_loop_header_p(), insert_into_preds_of_block(), ip_normal_pos(), is_cond_scalar_reduction(), is_inv_store_elimination_chain(), is_reassociable_op(), iv_elimination_compare(), loop_combined_static_and_iv_p(), loop_count_in(), loop_exit_edge_p(), loop_invariant_op_p(), loop_inverted_rev_post_order_compute(), loop_iter_phi_semi_invariant_p(), loop_rev_post_order_compute(), loop_static_op_p(), mark_irreducible_loops(), may_eliminate_iv(), tree_loop_interchange::move_code_to_inner_loop(), outermost_invariant_loop_for_expr(), parloops_is_simple_reduction(), parloops_is_slp_reduction(), predict_loops(), predict_paths_for_bb(), record_invariant(), rename_variables_in_bb(), rescan_loop_exit(), scale_dominated_blocks_in_loop(), should_duplicate_loop_header_p(), single_use_in_loop(), slpeel_tree_duplicate_loop_to_edge_cfg(), ssa_name_has_uses_outside_loop_p(), ssa_semi_invariant_p(), tree_unswitch_loop(), try_create_reduction_list(), unroll_jam_possible_p(), unroll_loop_runtime_iterations(), used_outside_loop_p(), vect_create_epilog_for_reduction(), vect_do_peeling(), vect_is_simple_iv_evolution(), vect_is_simple_reduction(), vect_loop_dist_alias_call(), vect_loop_kill_debug_uses(), vect_loop_versioning(), vect_phi_first_order_recurrence_p(), vect_stmt_relevant_p(), vectorizable_early_exit(), vectorizable_induction(), vectorizable_live_operation(), and verify_loop_structure().

◆ flow_loop_dump()

void flow_loop_dump ( const class loop * loop,
FILE * file,
void(* loop_dump_aux )(const class loop *, FILE *, int),
int verbose )
Dump the loop information specified by LOOP to the stream FILE
using auxiliary dump callback function LOOP_DUMP_AUX if non null.   

References FOR_EACH_VEC_ELT, free(), get_loop_body(), get_loop_latch_edges(), loop::header, i, basic_block_def::index, loop::latch, loop_depth(), loop_outer(), loop::num, loop::num_nodes, print_loop_info(), and verbose.

Referenced by analyze_and_mark_doloop_use(), flow_loops_dump(), and tree_ssa_iv_optimize().

◆ flow_loop_free()

void flow_loop_free ( class loop * loop)

◆ flow_loop_nested_p()

◆ flow_loop_nodes_find()

int flow_loop_nodes_find ( basic_block header,
class loop * loop )
Find the nodes contained within the LOOP with header HEADER.
Return the number of nodes within the loop.   

References CDI_DOMINATORS, dominated_by_p(), loop_exit::e, FOR_EACH_EDGE, loop::header, basic_block_def::loop_father, basic_block_def::preds, and vNULL.

Referenced by flow_loops_find().

◆ flow_loop_tree_node_add()

void flow_loop_tree_node_add ( class loop * father,
class loop * loop,
class loop * after )
Loop data structure manipulation/querying.   
Add LOOP to the loop hierarchy tree where FATHER is father of the
added loop.  If LOOP has some children, take care of that their
pred field will be initialized correctly.  If AFTER is non-null
then it's expected it's a pointer into FATHERs inner sibling
list and LOOP is added behind AFTER, otherwise it's added in front
of FATHERs siblings.   

References establish_preds(), loop::inner, and loop::next.

Referenced by add_loop(), copy_loops(), duplicate_loop(), fix_loop_placement(), fix_loop_structure(), flow_loops_find(), input_cfg(), merge_loop_tree(), move_sese_region_to_fn(), and unloop().

◆ flow_loop_tree_node_remove()

void flow_loop_tree_node_remove ( class loop * loop)

◆ flow_loops_dump()

void flow_loops_dump ( FILE * file,
void(* loop_dump_aux )(const class loop *, FILE *, int),
int verbose )
Dump the loop information about loops to the stream FILE,
using auxiliary dump callback function LOOP_DUMP_AUX if non null.   

References cfun, current_loops, flow_loop_dump(), flow_loops_cfg_dump(), LI_INCLUDE_ROOT, number_of_loops(), and verbose.

Referenced by analyze_function_body(), compute_alignments(), finite_function_p(), loop_optimizer_init(), and report_predictor_hitrates().

◆ flow_loops_find()

struct loops * flow_loops_find ( struct loops * loops)
Find all the natural loops in the function and save in LOOPS structure and
recalculate loop_father information in basic block structures.
If LOOPS is non-NULL then the loop structures for already recorded loops
will be re-used and their number will not change.  We assume that no
stale loops exist in LOOPS.
When LOOPS is NULL it is allocated and re-built from scratch.
Return the built LOOPS structure.   

References alloc_loop(), b, BASIC_BLOCK_FOR_FN, bb_loop_header_p(), calculate_dominance_info(), CDI_DOMINATORS, cfun, dump_file, dump_flags, loops::exits, flow_bb_inside_loop_p(), flow_loop_nodes_find(), flow_loop_tree_node_add(), flow_loop_tree_node_remove(), FOR_EACH_EDGE, free(), gcc_assert, ggc_cleared_alloc(), loop::header, i, basic_block_def::index, init_loops_structure(), loops::larray, loop::latch, basic_block_def::loop_father, n_basic_blocks_for_fn, NULL, loop::num, NUM_FIXED_BLOCKS, loop::num_nodes, pre_and_rev_post_order_compute(), basic_block_def::preds, TDF_DETAILS, loops::tree_root, and vec_safe_push().

Referenced by fix_loop_structure(), input_cfg(), and loop_optimizer_init().

◆ flow_loops_free()

void flow_loops_free ( struct loops * loops)
Free all the memory allocated for LOOPS.   

References flow_loop_free(), FOR_EACH_VEC_SAFE_ELT, i, loops::larray, and vec_free().

Referenced by loop_optimizer_finalize().

◆ free_simple_loop_desc()

void free_simple_loop_desc ( class loop * loop)
Releases simple loop description for LOOP.   

References ggc_free(), NULL, loop::simple_loop_desc, and simple_loop_desc().

Referenced by loop_optimizer_finalize().

◆ gcov_type_to_wide_int()

widest_int gcov_type_to_wide_int ( gcov_type val)
Converts VAL to widest_int.   

References a, and HOST_BITS_PER_WIDE_INT.

◆ get_estimated_loop_iterations()

bool get_estimated_loop_iterations ( class loop * loop,
widest_int * nit )
Sets NIT to the estimated number of executions of the latch of the
LOOP.  If we have no reliable estimate, the function returns false, otherwise
returns true.   

References loop::any_estimate, expected_loop_iterations_by_profile(), loop::nb_iterations_estimate, SIGNED, and sreal::to_nearest_int().

Referenced by decide_unroll_constant_iterations(), decide_unroll_runtime_iterations(), decide_unroll_stupid(), estimated_loop_iterations(), and get_estimated_loop_iterations_int().

◆ get_estimated_loop_iterations_int()

HOST_WIDE_INT get_estimated_loop_iterations_int ( class loop * loop)
Similar to get_estimated_loop_iterations, but returns the estimate only
if it fits to HOST_WIDE_INT.  If this is not the case, or the estimate
on the number of iterations of LOOP could not be derived, returns -1.   

References wi::fits_shwi_p(), get_estimated_loop_iterations(), and generic_wide_int< storage >::to_shwi().

Referenced by doloop_optimize(), find_simple_exit(), and generic_predict_doloop_p().

◆ get_iv_value()

rtx get_iv_value ( class rtx_iv * iv,
rtx iteration )
Calculates value of IV at ITERATION-th iteration.   

References iv::base, const0_rtx, gcc_assert, iv_extend_to_rtx_code(), IV_UNKNOWN_EXTEND, lowpart_subreg(), simplify_gen_binary(), simplify_gen_unary(), and iv::step.

Referenced by iv_extend(), and iv_subreg().

◆ get_likely_max_loop_iterations()

bool get_likely_max_loop_iterations ( class loop * loop,
widest_int * nit )
Sets NIT to an upper bound for the maximum number of executions of the
latch of the LOOP.  If we have no reliable estimate, the function returns
false, otherwise returns true.   

References loop::any_likely_upper_bound, loop::nb_iterations_likely_upper_bound, and SIGNED.

Referenced by decide_unroll_constant_iterations(), decide_unroll_runtime_iterations(), decide_unroll_stupid(), get_likely_max_loop_iterations_int(), and likely_max_loop_iterations().

◆ get_likely_max_loop_iterations_int()

HOST_WIDE_INT get_likely_max_loop_iterations_int ( class loop * loop)
Similar to get_max_loop_iterations, but returns the estimate only
if it fits to HOST_WIDE_INT.  If this is not the case, or the estimate
on the number of iterations of LOOP could not be derived, returns -1.   

References wi::fits_shwi_p(), get_likely_max_loop_iterations(), and generic_wide_int< storage >::to_shwi().

Referenced by doloop_optimize(), find_simple_exit(), generic_predict_doloop_p(), likely_max_stmt_executions_int(), parallelize_loops(), and scale_profile_for_vect_loop().

◆ get_loop()

◆ get_loop_body()

basic_block * get_loop_body ( const class loop * loop)
Loops & cfg manipulation.   
Gets basic blocks of a LOOP.  Header is the 0-th block, rest is in dfs
order against direction of edges from latch.  Specially, if
header != latch, latch is the 1-st block.   

References cfun, EXIT_BLOCK_PTR_FOR_FN, FOR_EACH_BB_FN, gcc_assert, get_loop_body_with_size(), loop::header, loop::latch, n_basic_blocks_for_fn, and loop::num_nodes.

Referenced by analyze_function_body(), analyze_insns_in_loop(), average_num_loop_insns(), can_duplicate_loop_p(), cancel_loop(), determine_reduction_stmt(), doloop_valid_p(), draw_cfg_nodes_for_loop(), estimate_loops_at_level(), estimate_numbers_of_iterations(), find_loop_guard(), find_simple_exit(), fix_bb_placements(), fix_loop_bb_probability(), flow_loop_dump(), free_rdg(), get_loop_body_in_custom_order(), get_loop_body_in_custom_order(), get_loop_exit_edges(), hoist_guard(), ifcvt_split_critical_edges(), init_loop_unswitch_info(), loop_has_phi_with_address_arg(), loop_nest_has_data_refs(), num_loop_branches(), num_loop_insns(), number_of_iterations_exit_assumptions(), optimize_mask_stores(), predict_loops(), referenced_in_one_insn_in_loop_p(), reset_debug_uses_in_loop(), scale_loop_frequencies(), set_uid_loop_bbs(), simplify_loop_version(), split_loop(), split_loop_on_cond(), tree_estimate_loop_size(), tree_num_loop_insns(), tree_ssa_iv_optimize_loop(), tree_unswitch_single_loop(), unloop(), unroll_loop_runtime_iterations(), update_dominators_in_loop(), update_epilogue_loop_vinfo(), vect_analyze_loop_form(), vect_do_peeling(), and verify_loop_closed_ssa().

◆ get_loop_body_in_bfs_order()

basic_block * get_loop_body_in_bfs_order ( const class loop * loop)

◆ get_loop_body_in_custom_order() [1/2]

basic_block * get_loop_body_in_custom_order ( const class loop * loop,
int(* bb_comparator )(const void *, const void *) )
Gets body of a LOOP sorted via provided BB_COMPARATOR.   

References get_loop_body(), loop::num_nodes, and qsort.

Referenced by loop_distribution::stmts_from_loop().

◆ get_loop_body_in_custom_order() [2/2]

basic_block * get_loop_body_in_custom_order ( const class loop * loop,
void * data,
int(* bb_comparator )(const void *, const void *, void *) )
Same as above, but use gcc_sort_r instead of qsort.   

References gcc_sort_r(), get_loop_body(), and loop::num_nodes.

◆ get_loop_body_in_dom_order()

basic_block * get_loop_body_in_dom_order ( const class loop * loop)

◆ get_loop_body_with_size()

unsigned get_loop_body_with_size ( const class loop * loop,
basic_block * body,
unsigned max_size )
Gets basic blocks of a LOOP.  Header is the 0-th block, rest is in dfs
order against direction of edges from latch.  Specially, if
header != latch, latch is the 1-st block.  LOOP cannot be the fake
loop tree root, and its size must be at most MAX_SIZE.  The blocks
in the LOOP body are stored to BODY, and the size of the LOOP is

References dfs_enumerate_from(), glb_enum_p(), and loop::header.

Referenced by add_loop(), get_loop_body(), merge_loop_tree(), slpeel_can_duplicate_loop_p(), slpeel_tree_duplicate_loop_to_edge_cfg(), unroll_jam_possible_p(), and verify_loop_structure().

◆ get_loop_exit_edges()

◆ get_loop_hot_path()

auto_vec< basic_block > get_loop_hot_path ( const class loop * loop)
Gets basic blocks of a LOOP.  Header is the 0-th block, rest is in dfs
order against direction of edges from latch.  Specially, if
header != latch, latch is the 1-st block.   

References BITMAP_ALLOC, bitmap_bit_p, BITMAP_FREE, bitmap_set_bit, FOR_EACH_EDGE, loop::header, basic_block_def::index, loop_exit_edge_p(), NULL, path, basic_block_def::succs, and visited.

Referenced by tree_estimate_loop_size().

◆ get_loop_level()

unsigned get_loop_level ( const class loop * loop)
Returns the maximum level of nesting of subloops of LOOP.   

References get_loop_level(), loop::inner, and loop::next.

Referenced by doloop_optimize(), and get_loop_level().

◆ get_loop_location()

dump_user_location_t get_loop_location ( class loop * loop)

◆ get_loops()

◆ get_max_loop_iterations()

bool get_max_loop_iterations ( const class loop * loop,
widest_int * nit )
Sets NIT to an upper bound for the maximum number of executions of the
latch of the LOOP.  If we have no reliable estimate, the function returns
false, otherwise returns true.   

References loop::any_upper_bound, loop::nb_iterations_upper_bound, and SIGNED.

Referenced by doloop_modify(), doloop_optimize(), doloop_simplify_count(), get_max_loop_iterations_int(), iv_can_overflow_p(), loop_niters_no_overflow(), and max_loop_iterations().

◆ get_max_loop_iterations_int()

HOST_WIDE_INT get_max_loop_iterations_int ( const class loop * loop)
Similar to get_max_loop_iterations, but returns the estimate only
if it fits to HOST_WIDE_INT.  If this is not the case, or the estimate
on the number of iterations of LOOP could not be derived, returns -1.   

References wi::fits_shwi_p(), get_max_loop_iterations(), and generic_wide_int< storage >::to_shwi().

Referenced by expected_loop_iterations_unbounded(), find_simple_exit(), max_stmt_executions_int(), and pcom_worker::tree_predictive_commoning_loop().

◆ get_simple_loop_desc()

◆ init_loops_structure()

void init_loops_structure ( struct function * fn,
struct loops * loops,
unsigned num_loops )
Initializes loops structure LOOPS, reserving place for NUM_LOOPS loops
(including the root of the loop tree).   

References alloc_loop(), ENTRY_BLOCK_PTR_FOR_FN, EXIT_BLOCK_PTR_FOR_FN, loop::header, loops::larray, loop::latch, n_basic_blocks_for_fn, loop::num_nodes, loops::tree_root, and vec_alloc().

Referenced by flow_loops_find(), init_lowered_empty_function(), input_cfg(), and move_sese_region_to_fn().

◆ init_set_costs()

◆ iv_analysis_done()

void iv_analysis_done ( void )
Free the data for an induction variable analysis.   

References bivs, clean_slate, clear_iv_info(), df_finish_pass(), free(), iv_ref_table, iv_ref_table_size, and NULL.

Referenced by doloop_optimize_loops(), and unroll_loops().

◆ iv_analysis_loop_init()

◆ iv_analyze()

bool iv_analyze ( rtx_insn * insn,
scalar_int_mode mode,
rtx val,
class rtx_iv * iv )
Analyzes value VAL at INSN and stores the result to *IV.  MODE is the
mode of VAL.   

References df_find_use(), GET_CODE, iv_analyze_op(), rtx_iv::mode, NEXT_INSN(), simple_reg_p(), and SUBREG_REG.

Referenced by iv_number_of_iterations().

◆ iv_analyze_expr()

bool iv_analyze_expr ( rtx_insn * insn,
scalar_int_mode mode,
rtx rhs,
class rtx_iv * iv )
Analyzes expression RHS used at INSN and stores the result to *IV.
The mode of the induction variable is MODE.   

References iv::base, CONSTANT_P, gcc_assert, GET_CODE, GET_MODE, is_a(), iv_add(), iv_analyze_expr(), iv_analyze_op(), iv_extend(), iv_mult(), iv_neg(), iv_shift(), IV_SIGN_EXTEND, IV_ZERO_EXTEND, rtx_iv::mode, NULL_RTX, REG_P, iv::step, and XEXP.

Referenced by iv_analyze_def(), and iv_analyze_expr().

◆ iv_analyze_result()

bool iv_analyze_result ( rtx_insn * insn,
rtx def,
class rtx_iv * iv )
Analyzes definition of DEF in INSN and stores the result to IV.   

References df_find_def(), and iv_analyze_def().

Referenced by analyze_iv_to_split_insn().

◆ just_once_each_iteration_p()

◆ loop_constraint_clear()

void loop_constraint_clear ( class loop * loop,
unsigned c )
Clear C from the LOOP constraint.   

References loop::constraints.

Referenced by vect_do_peeling(), and vect_free_loop_info_assumptions().

◆ loop_constraint_set()

void loop_constraint_set ( class loop * loop,
unsigned c )
Set C to the LOOP constraint.   

References loop::constraints.

Referenced by vect_analyze_loop().

◆ loop_constraint_set_p()

bool loop_constraint_set_p ( class loop * loop,
unsigned c )
Check if C is set in the LOOP constraint.   

References loop::constraints.

Referenced by number_of_iterations_exit_assumptions(), try_vectorize_loop_1(), and vect_loop_versioning().

◆ loop_count_in()

◆ loop_depth()

◆ loop_exit_edge_p()

◆ loop_exits_from_bb_p()

bool loop_exits_from_bb_p ( class loop * loop,
basic_block bb )

◆ loop_exits_to_bb_p()

bool loop_exits_to_bb_p ( class loop * loop,
basic_block bb )
Returns true when BB has an incoming edge exiting LOOP.   

References loop_exit::e, FOR_EACH_EDGE, loop_exit_edge_p(), and basic_block_def::preds.

◆ loop_has_exit_edges()

bool loop_has_exit_edges ( const class loop * loop)
Returns true if LOOP has at least one exit edge.   

References loop_exit::e, loop::exits, loop_exit::next, and NULL.

◆ loop_latch_edge()

edge loop_latch_edge ( const class loop * loop)
Returns latch edge of LOOP.   

References find_edge(), loop::header, and loop::latch.

Referenced by add_iv_candidate_for_biv(), analyze_and_compute_bitop_with_inv_effect(), analyze_and_compute_bitwise_induction_effect(), loop_cand::analyze_iloop_reduction_var(), loop_cand::analyze_oloop_reduction_var(), connect_loop_phis(), constant_after_peeling(), create_iv(), create_parallel_loop(), create_preheader(), discover_iteration_bound_by_body_walk(), do_split_loop_on_cond(), duplicate_loop_body_to_header_edge(), easy_exit_values(), eliminate_temp_copies(), estimate_loops_at_level(), pcom_worker::find_looparound_phi(), find_vdef_in_loop(), fuse_loops(), get_base_for(), ifcvt_local_dce(), initialize_root_vars(), initialize_root_vars_lm(), initialize_root_vars_store_elim_2(), is_cond_scalar_reduction(), loop_iter_phi_semi_invariant_p(), loop_niter_by_eval(), mark_bivs(), maybe_lower_iteration_bound(), maybe_set_vectorized_backedge_value(), number_of_iterations_cltz(), number_of_iterations_cltz_complement(), number_of_iterations_popcount(), parloops_is_simple_reduction(), process_use(), slpeel_tree_duplicate_loop_to_edge_cfg(), split_loop(), fwd_jt_path_registry::thread_through_loop_header(), tree_transform_and_unroll_loop(), unloop_loops(), unroll_loop_constant_iterations(), unroll_loop_runtime_iterations(), unroll_loop_stupid(), vect_build_slp_instance(), vect_build_slp_tree_2(), vect_create_epilog_for_reduction(), vect_is_nonlinear_iv_evolution(), vect_is_simple_reduction(), vect_phi_first_order_recurrence_p(), vect_set_loop_control(), vectorizable_induction(), vectorizable_load(), vectorizable_nonlinear_induction(), vectorizable_recurr(), vectorizable_reduction(), and vectorizable_simd_clone_call().

◆ loop_optimizer_finalize() [1/2]

◆ loop_optimizer_finalize() [2/2]

◆ loop_optimizer_init()

◆ loop_outer()

class loop * loop_outer ( const class loop * loop)
Returns the immediate superloop of LOOP, or NULL if LOOP is the outermost

References NULL, loop::superloops, and vec_safe_length().

Referenced by add_exit_phis(), add_loop(), add_loop_to_tree(), analyze_memory_references(), analyze_scalar_evolution_in_loop(), calculate_loop_reg_pressure(), cancel_loop(), compute_access_range(), compute_access_stride(), compute_invariantness(), create_loop_tree_nodes(), determine_loop_nest_reuse(), dfs_find_deadend(), do_not_sink(), duplicate_block(), dw2_build_landing_pads(), eliminate_dom_walker::eliminate_stmt(), fill_coldest_and_hotter_out_loop(), find_common_loop(), find_loop_location(), find_sibling_superloop(), find_uses_to_rename_use(), fix_bb_placement(), fix_bb_placements(), fix_loop_placement(), fix_loop_placements(), fix_loop_structure(), flow_loop_dump(), flow_loop_tree_node_remove(), form_loop_tree(), fwprop_insn(), gbb_loop_at_index(), get_all_loop_exits(), gimple_duplicate_seme_region(), init_loop_unswitch_info(), tree_loop_interchange::interchange_loops(), loop_preheader_edge(), loop_version(), make_forwarder_block(), mark_loop_exit_edges(), mark_loops_in_oacc_kernels_region(), mark_ref_loaded(), mark_ref_regs(), mark_ref_stored(), mark_regno_live(), merge_loop_tree(), move_computations_worker(), move_sese_region_to_fn(), optimize_loop_nest_for_size_p(), optimize_loop_nest_for_speed_p(), outermost_invariant_loop(), outermost_loop_in_sese_1(), predict_loops(), prepare_perfect_loop_nest(), fold_using_range::range_of_phi(), remove_ctrl_stmt_and_useless_edges(), remove_edge_and_dominated_blocks(), remove_path(), rename_variables_in_bb(), rescan_loop_exit(), sese_loop_depth(), set_level(), sjlj_emit_dispatch_table(), slpeel_can_duplicate_loop_p(), slpeel_tree_duplicate_loop_to_edge_cfg(), fwd_jt_path_registry::thread_block_1(), fwd_jt_path_registry::thread_through_loop_header(), tree_forwarder_block_p(), tree_if_conversion(), tree_loop_unroll_and_jam(), tree_ssa_split_loops(), tree_unroll_loops_completely(), tree_unroll_loops_completely_1(), unloop(), vect_analyze_early_break_dependences(), vect_analyze_loop(), vect_loop_versioning(), verify_loop_structure(), versionable_outer_loop_p(), and loops_list::walk_loop_tree().

◆ loop_outermost()

class loop * loop_outermost ( class loop * loop)
Returns the outermost loop of the loop nest that contains LOOP. 

References loop::superloops, and vec_safe_length().

Referenced by gather_memory_references_ref().

◆ loop_preheader_edge()

edge loop_preheader_edge ( const class loop * loop)
Returns preheader edge of LOOP.   

References cfun, loop_exit::e, ENTRY_BLOCK_PTR_FOR_FN, FOR_EACH_EDGE, gcc_assert, loop::header, loop::latch, loop_outer(), LOOPS_HAVE_PREHEADERS, LOOPS_MAY_HAVE_MULTIPLE_LATCHES, loops_state_satisfies_p(), basic_block_def::preds, and single_succ_edge().

Referenced by add_preheader_seq(), analyze_and_compute_bitop_with_inv_effect(), analyze_and_compute_bitwise_induction_effect(), loop_cand::analyze_carried_vars(), analyze_function_body(), loop_cand::analyze_iloop_reduction_var(), loop_cand::analyze_induction_var(), analyze_insns_in_loop(), loop_cand::analyze_oloop_reduction_var(), bb_colder_than_loop_preheader(), block_before_loop(), build_region(), canonicalize_loop_ivs(), check_exit_phi(), compute_access_stride(), connect_loop_phis(), connect_loops(), constant_after_peeling(), copy_loop_before(), create_empty_loop_on_edge(), create_iv(), create_parallel_loop(), cse_and_gimplify_to_preheader(), destroy_loop(), determine_exit_conditions(), determine_loop_nest_reuse(), determine_value_range(), do_split_loop_on_cond(), doloop_modify(), execute_sm(), execute_sm_exit(), fill_coldest_and_hotter_out_loop(), find_bivs(), find_data_references_in_stmt(), find_invariants_bb(), pcom_worker::find_looparound_phi(), find_reduc_addr(), fix_loop_placements(), gen_parallel_loop(), generate_memcpy_builtin(), generate_memset_builtin(), generate_reduction_builtin_1(), get_base_for(), get_range_query(), get_vop_from_header(), hoist_defs_of_uses(), hoist_guard(), hoist_memory_references(), ifcvt_can_hoist(), initialize_data_dependence_relation(), initialize_reductions(), initialize_root_vars(), initialize_root_vars_lm(), initialize_root_vars_store_elim_2(), insert_init_seqs(), vec_info::insert_seq_on_entry(), instantiate_parameters(), tree_loop_interchange::interchange_loops(), loop_niter_by_eval(), loop_rev_post_order_compute(), loop_version(), move_computations_worker(), move_invariant_reg(), number_of_iterations_cltz(), number_of_iterations_cltz_complement(), number_of_iterations_popcount(), parallelize_loops(), predict_loops(), pcom_worker::prepare_initializers_chain(), resolve_mixers(), rewrite_use_compare(), scale_profile_for_vect_loop(), simplify_using_initial_values(), slpeel_can_duplicate_loop_p(), slpeel_tree_duplicate_loop_to_edge_cfg(), slpeel_update_phi_nodes_for_guard1(), split_loop(), stmt_semi_invariant_p_1(), transform_to_exit_first_loop_alt(), tree_if_conversion(), tree_loop_unroll_and_jam(), tree_transform_and_unroll_loop(), tree_unroll_loops_completely(), try_peel_loop(), try_transform_to_exit_first_loop_alt(), try_unroll_loop_completely(), unloop(), unroll_loop_constant_iterations(), unroll_loop_runtime_iterations(), vect_analyze_loop_form(), vect_build_loop_niters(), vect_build_slp_tree_2(), vect_create_data_ref_ptr(), vect_create_epilog_for_reduction(), vect_do_peeling(), vect_emit_reduction_init_stmts(), vect_enhance_data_refs_alignment(), vect_gen_vector_loop_niters(), vect_get_external_def_edge(), vect_get_gather_scatter_ops(), vect_is_nonlinear_iv_evolution(), vect_loop_dist_alias_call(), vect_loop_vectorized_call(), vect_loop_versioning(), vect_phi_initial_value(), vect_prepare_for_masked_peels(), vect_set_loop_condition_normal(), vect_set_loop_control(), vect_setup_realignment(), vect_transform_cycle_phi(), vect_transform_loop(), vect_update_ivs_after_vectorizer(), vectorizable_induction(), vectorizable_load(), vectorizable_nonlinear_induction(), vectorizable_recurr(), and vectorizable_simd_clone_call().

◆ loops_state_clear() [1/2]

void loops_state_clear ( function * fn,
unsigned flags )

◆ loops_state_clear() [2/2]

void loops_state_clear ( unsigned flags)

◆ loops_state_satisfies_p() [1/2]

◆ loops_state_satisfies_p() [2/2]

bool loops_state_satisfies_p ( unsigned flags)

References cfun, and loops_state_satisfies_p().

◆ loops_state_set() [1/2]

◆ loops_state_set() [2/2]

void loops_state_set ( unsigned flags)

References cfun, and loops_state_set().

◆ mark_irreducible_loops()

◆ mark_loop_exit_edges()

void mark_loop_exit_edges ( void )

◆ mark_loop_for_removal()

◆ maybe_flat_loop_profile()

bool maybe_flat_loop_profile ( const class loop * loop)
Return true if loop CFG profile may be unrealistically flat.
This is a common case, since average loops iterate only about 5 times.
In the case we do not have profile feedback or do not know real number of
iterations during profile estimation, we are likely going to predict it with
similar low iteration count.  For static loop profiles we also artificially
cap profile of loops with known large iteration count so they do not appear
significantly more hot than other loops with unknown iteration counts.

For loop optimization heuristics we ignore CFG profile and instead
use get_estimated_loop_iterations API which returns estimate
only when it is realistic.  For unknown counts some optimizations,
like vectorizer or unroller make guess that iteration count will
be large.  In this case we need to avoid scaling down the profile
after the loop transform.   

References loop::any_estimate, loop::any_likely_upper_bound, loop::any_upper_bound, dump_file, dump_flags, expected_loop_iterations_by_profile(), wi::geu_p(), wi::gtu_p(), wi::ltu_p(), loop::nb_iterations_estimate, loop::nb_iterations_likely_upper_bound, loop::nb_iterations_upper_bound, loop::num, TDF_DETAILS, sreal::to_double(), sreal::to_nearest_int(), and generic_wide_int< storage >::to_shwi().

Referenced by print_loop_info(), tree_transform_and_unroll_loop(), unroll_loop_constant_iterations(), and vect_transform_loop().

◆ move_loop_invariants()

◆ num_loop_branches()

unsigned num_loop_branches ( const class loop * loop)
Counts the number of conditional branches inside LOOP.   

References cfun, EDGE_COUNT, EXIT_BLOCK_PTR_FOR_FN, free(), gcc_assert, get_loop_body(), i, loop::latch, and loop::num_nodes.

Referenced by decide_unroll_stupid().

◆ num_loop_insns()

int num_loop_insns ( const class loop * loop)

◆ number_of_loops()

◆ print_loop_info()

◆ record_loop_exits()

◆ record_niter_bound()

void record_niter_bound ( class loop * loop,
const widest_int & i_bound,
bool realistic,
bool upper )
Records that every statement in LOOP is executed I_BOUND times.
REALISTIC is true if I_BOUND is expected to be close to the real number
of iterations.  UPPER is true if we are sure the loop iterates at most
I_BOUND times.   

References loop::any_estimate, loop::any_likely_upper_bound, loop::any_upper_bound, wi::ltu_p(), wi::min_precision(), loop::nb_iterations_estimate, loop::nb_iterations_likely_upper_bound, loop::nb_iterations_upper_bound, and SIGNED.

Referenced by branch_prob(), canonicalize_loop_induction_variables(), discover_iteration_bound_by_body_walk(), estimate_numbers_of_iterations(), iv_number_of_iterations(), maybe_lower_iteration_bound(), record_estimate(), and vect_do_peeling().

◆ release_recorded_exits()

◆ remove_bb_from_loops()

◆ rescan_loop_exit()

◆ simple_loop_desc()

class niter_desc * simple_loop_desc ( class loop * loop)

◆ single_dom_exit()

◆ single_exit()

◆ single_likely_exit()

edge single_likely_exit ( class loop * loop,
const vec< edge > & exits )
Return exit edge if loop has only one exit that is likely
to be executed on runtime (i.e. it is not EH or leading
to noreturn call.   

References cfun, loop::exits, FOR_EACH_VEC_ELT, i, NULL, probably_never_executed_edge_p(), single_exit(), and profile_probability::very_unlikely().

Referenced by canonicalize_loop_induction_variables(), estimate_numbers_of_iterations(), and loop_exit_for_scaling().

◆ sort_sibling_loops()

◆ superloop_at_depth()

◆ verify_loop_structure()

void verify_loop_structure ( void )
Disable warnings about missing quoting in GCC diagnostics for
the verification errors.  Their format strings don't follow GCC
diagnostic conventions and the calls are ultimately followed by
a deliberate ICE triggered by a failed assertion.   
Checks that information about loops is correct
  -- sizes of loops are all right
  -- results of get_loop_body really belong to the loop
  -- loop header have just single entry edge and single latch edge
  -- loop latches have only single successor that is header of their loop
  -- irreducible loops are correctly marked
  -- the cached loop depth and loop father of each bb is correct

References bb_loop_header_p(), bitmap_bit_p, bitmap_clear(), bitmap_set_bit, calculate_dominance_info(), CDI_DOMINATORS, cfun, current_loops, dom_info_available_p(), dominated_by_p(), loop_exit::e, EDGE_COUNT, ENTRY_BLOCK_PTR_FOR_FN, error(), EXIT_BLOCK_PTR_FOR_FN, loop::exits, find_edge(), find_released_ssa_name(), basic_block_def::flags, flow_bb_inside_loop_p(), FOR_EACH_BB_FN, FOR_EACH_EDGE, free(), free_dominance_info(), gcc_assert, get_exit_descriptions(), get_loop_body_with_size(), loop::header, i, basic_block_def::index, last_basic_block_for_fn, loop::latch, LI_FROM_INNERMOST, basic_block_def::loop_father, loop_outer(), LOOPS_HAVE_MARKED_IRREDUCIBLE_REGIONS, LOOPS_HAVE_PREHEADERS, LOOPS_HAVE_RECORDED_EXITS, LOOPS_HAVE_SIMPLE_LATCHES, LOOPS_NEED_FIXUP, loops_state_satisfies_p(), mark_irreducible_loops(), n_basic_blocks_for_fn, loop::nb_iterations, loop_exit::next, loop_exit::next_e, NULL, loop::num, loop::num_nodes, number_of_loops(), basic_block_def::preds, single_succ(), single_succ_p(), basic_block_def::succs, verify_dominators(), visited, and walk_tree.

Referenced by checking_verify_loop_structure(), execute_function_todo(), expand_omp_target(), and expand_omp_taskreg().

Variable Documentation

◆ default_target_cfgloop

struct target_cfgloop default_target_cfgloop
Natural loop analysis code for GNU compiler.
   Copyright (C) 2002-2024 Free Software Foundation, Inc.

This file is part of GCC.

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

GCC is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or
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