GCC Middle and Back End API Reference
cgraph_edge Class Reference

#include <cgraph.h>

Collaboration diagram for cgraph_edge:

Public Member Functions

void redirect_callee (cgraph_node *n)
 
void redirect_callee_duplicating_thunks (cgraph_node *n)
 
cgraph_edgemake_speculative (cgraph_node *n2, profile_count direct_count, unsigned int speculative_id=0)
 
cgraph_edgefirst_speculative_call_target ()
 
cgraph_edgenext_speculative_call_target ()
 
cgraph_edgespeculative_call_indirect_edge ()
 
cgraph_edgespeculative_call_for_target (cgraph_node *)
 
ipa_refspeculative_call_target_ref ()
 
cgraph_edgeclone (cgraph_node *n, gcall *call_stmt, unsigned stmt_uid, profile_count num, profile_count den, bool update_original)
 
bool verify_count ()
 
bool cannot_lead_to_return_p (void)
 
bool recursive_p (void)
 
bool maybe_hot_p (void)
 
int get_uid ()
 
int get_summary_id ()
 
bool possibly_call_in_translation_unit_p (void)
 
int num_speculative_call_targets_p (void)
 
bool binds_to_current_def_p ()
 
int frequency ()
 
sreal sreal_frequency ()
 

Static Public Member Functions

static void remove (cgraph_edge *edge)
 
static cgraph_edgeset_call_stmt (cgraph_edge *e, gcall *new_stmt, bool update_speculative=true)
 
static cgraph_edgemake_direct (cgraph_edge *edge, cgraph_node *callee)
 
static cgraph_edgeresolve_speculation (cgraph_edge *edge, tree callee_decl=NULL)
 
static gimpleredirect_call_stmt_to_callee (cgraph_edge *e, hash_set< tree > *killed_ssas=nullptr)
 
static unsigned int rebuild_edges (void)
 
static void rebuild_references (void)
 

Data Fields

profile_count count
 
cgraph_nodecaller
 
cgraph_nodecallee
 
cgraph_edgeprev_caller
 
cgraph_edgenext_caller
 
cgraph_edgeprev_callee
 
cgraph_edgenext_callee
 
gcallcall_stmt
 
cgraph_indirect_call_infoindirect_info
 
void * aux
 
enum cgraph_inline_failed_t inline_failed
 
unsigned int lto_stmt_uid
 
unsigned int speculative_id: 16
 
unsigned int indirect_inlining_edge: 1
 
unsigned int indirect_unknown_callee: 1
 
unsigned int call_stmt_cannot_inline_p: 1
 
unsigned int can_throw_external: 1
 
unsigned int speculative: 1
 
unsigned in_polymorphic_cdtor: 1
 

Private Member Functions

void remove_caller (void)
 
void remove_callee (void)
 
void set_callee (cgraph_node *n)
 
void dump_edge_flags (FILE *f)
 
void DEBUG_FUNCTION debug (void)
 
bool verify_corresponds_to_fndecl (tree decl)
 

Private Attributes

int m_uid
 
int m_summary_id
 

Friends

struct cgraph_node
 
class symbol_table
 

Member Function Documentation

◆ binds_to_current_def_p()

bool cgraph_edge::binds_to_current_def_p ( )
inline
Return true if call must bind to current definition.   

References symtab_node::binds_to_current_def_p(), callee, and caller.

◆ cannot_lead_to_return_p()

bool cgraph_edge::cannot_lead_to_return_p ( void )
Return true when call of edge cannot lead to return from caller
and thus it is safe to ignore its side effects for IPA analysis
when computing side effects of the caller.
FIXME: We could actually mark all edges that have no reaching
patch to the exit block or throw to get better results.   

References callee, caller, cgraph_node::cannot_return_p(), symtab_node::decl, cgraph_indirect_call_info::ecf_flags, ECF_NORETURN, ECF_NOTHROW, indirect_info, indirect_unknown_callee, and opt_for_fn.

Referenced by get_read_write_all_from_node(), propagate_bits(), and propagate_pure_const().

◆ clone()

cgraph_edge * cgraph_edge::clone ( cgraph_node * n,
gcall * call_stmt,
unsigned stmt_uid,
profile_count num,
profile_count den,
bool update_original )
Callgraph clones
   Copyright (C) 2003-2024 Free Software Foundation, Inc.
   Contributed by Jan Hubicka

This file is part of GCC.

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

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

You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING3.  If not see
<http://www.gnu.org/licenses/>.   
This module provide facilities for cloning functions.  I.e. creating
new functions based on existing functions with simple modifications,
such as replacement of parameters.

To allow whole program optimization without actual presence of function
bodies, an additional infrastructure is provided for so-called virtual
clones

A virtual clone in the callgraph is a function that has no
associated body, just a description of how to create its body based
on a different function (which itself may be a virtual clone).

The description of function modifications includes adjustments to
the function's signature (which allows, for example, removing or
adding function arguments), substitutions to perform on the
function body, and, for inlined functions, a pointer to the
function that it will be inlined into.

It is also possible to redirect any edge of the callgraph from a
function to its virtual clone.  This implies updating of the call
site to adjust for the new function signature.

Most of the transformations performed by inter-procedural
optimizations can be represented via virtual clones.  For
instance, a constant propagation pass can produce a virtual clone
of the function which replaces one of its arguments by a
constant.  The inliner can represent its decisions by producing a
clone of a function whose body will be later integrated into
a given function.

Using virtual clones, the program can be easily updated
during the Execute stage, solving most of pass interactions
problems that would otherwise occur during Transform.

Virtual clones are later materialized in the LTRANS stage and
turned into real functions.  Passes executed after the virtual
clone were introduced also perform their Transform stage
on new functions, so for a pass there is no significant
difference between operating on a real function or a virtual
clone introduced before its Execute stage.

Optimization passes then work on virtual clones introduced before
their Execute stage as if they were real functions.  The
only difference is that clones are not visible during the
Generate Summary stage.   
Create clone of edge in the node N represented by CALL_EXPR
the callgraph.   

References profile_count::adjust_for_ipa_scaling(), profile_count::apply_scale(), symbol_table::call_edge_duplication_hooks(), call_stmt, call_stmt_cannot_inline_p, callee, caller, can_throw_external, profile_count::combine_with_ipa_count_within(), count, cgraph_node::count, cgraph_node::create_edge(), cgraph_node::create_indirect_edge(), cgraph_indirect_call_info::ecf_flags, gcc_checking_assert, cgraph_node::get(), ggc_cleared_alloc(), gimple_call_fndecl(), in_polymorphic_cdtor, indirect_info, indirect_inlining_edge, indirect_unknown_callee, inline_failed, profile_count::ipa(), lto_stmt_uid, speculative, speculative_id, and symtab.

Referenced by copy_bb(), cgraph_node::create_clone(), and cgraph_node::create_version_clone().

◆ debug()

void cgraph_edge::debug ( void )
private

◆ dump_edge_flags()

void cgraph_edge::dump_edge_flags ( FILE * f)
private

◆ first_speculative_call_target()

cgraph_edge * cgraph_edge::first_speculative_call_target ( )
Speculative call consists of an indirect edge and one or more
direct edge+ref pairs.

Given an edge which is part of speculative call, return the first
direct call edge in the speculative call sequence.   

References call_stmt, callee, cgraph_node::callees, caller, gcc_checking_assert, cgraph_node::get_edge(), lto_stmt_uid, next_callee, prev_callee, and speculative.

Referenced by ipa_merge_profiles(), make_direct(), redirect_call_stmt_to_callee(), resolve_speculation(), set_call_stmt(), speculative_call_for_target(), and update_indirect_edges_after_inlining().

◆ frequency()

int cgraph_edge::frequency ( )
inline
Expected frequency of executions within the function.
When set to CGRAPH_FREQ_BASE, the edge is expected to be called once
per function call.  The range is 0 to CGRAPH_FREQ_MAX.   

References caller, count, cgraph_node::count, cgraph_node::inlined_to, and profile_count::to_cgraph_frequency().

◆ get_summary_id()

int cgraph_edge::get_summary_id ( )
inline

References m_summary_id.

◆ get_uid()

int cgraph_edge::get_uid ( )
inline

References m_uid.

◆ make_direct()

cgraph_edge * cgraph_edge::make_direct ( cgraph_edge * edge,
cgraph_node * callee )
static

◆ make_speculative()

cgraph_edge * cgraph_edge::make_speculative ( cgraph_node * n2,
profile_count direct_count,
unsigned int speculative_id = 0 )
Turn edge into speculative call calling N2. Update
the profile so the direct call is taken COUNT times
with FREQUENCY.  

At clone materialization time, the indirect call E will
be expanded as:

if (call_dest == N2)
  n2 ();
else
  call call_dest

At this time the function just creates the direct call,
the reference representing the if conditional and attaches
them all to the original indirect call statement.  

speculative_id is used to link direct calls with their corresponding
IPA_REF_ADDR references when representing speculative calls.

Return direct edge created.   

References symbol_table::call_edge_duplication_hooks(), call_stmt, caller, can_throw_external, count, cgraph_node::create_edge(), symtab_node::create_reference(), symtab_node::decl, dump_file, symtab_node::dump_name(), in_polymorphic_cdtor, indirect_info, initialize_inline_failed(), IPA_REF_ADDR, lto_stmt_uid, ipa_ref::lto_stmt_uid, cgraph_node::mark_address_taken(), NULL, cgraph_indirect_call_info::num_speculative_call_targets, speculative, ipa_ref::speculative, speculative_id, ipa_ref::speculative_id, symtab, and TREE_NOTHROW.

Referenced by autofdo::afdo_indirect_call(), ipa_devirt(), ipa_make_edge_direct_to_target(), ipa_merge_profiles(), and ipa_profile().

◆ maybe_hot_p()

◆ next_speculative_call_target()

◆ num_speculative_call_targets_p()

int cgraph_edge::num_speculative_call_targets_p ( void )

◆ possibly_call_in_translation_unit_p()

bool cgraph_edge::possibly_call_in_translation_unit_p ( void )

◆ rebuild_edges()

◆ rebuild_references()

void cgraph_edge::rebuild_references ( void )
static

◆ recursive_p()

◆ redirect_call_stmt_to_callee()

gimple * cgraph_edge::redirect_call_stmt_to_callee ( cgraph_edge * e,
hash_set< tree > * killed_ssas = nullptr )
static
If necessary, change the function declaration in the call statement
associated with E so that it corresponds to the edge callee.  Speculations
can be resolved in the process and EDGE can be removed and deallocated.

The edge could be one of speculative direct call generated from speculative
indirect call.  In this circumstance, decrease the speculative targets
count (i.e. num_speculative_call_targets) and redirect call stmt to the
corresponding i-th target.  If no speculative direct call left to the
speculative indirect call, remove "speculative" of the indirect call and
also redirect stmt to it's final direct target.

When called from within tree-inline, KILLED_SSAs has to contain the pointer
to killed_new_ssa_names within the copy_body_data structure and SSAs
discovered to be useless (if LHS is removed) will be added to it, otherwise
it needs to be NULL.

It is up to caller to iteratively transform each "speculative"
direct call as appropriate.   

References add_stmt_to_eh_lp(), call_stmt, callee, caller, cgraph_node::clone_of, basic_block_def::count, count, create_tmp_reg_fn(), symtab_node::decl, DECL_STATIC_CHAIN, DECL_STRUCT_FUNCTION, ipa_param_adjustments::dump(), profile_count::dump(), dump_file, symbol_table::dump_file, dump_flags, symtab_node::dump_name(), dyn_cast(), profile_probability::even(), first_speculative_call_target(), fndecl_built_in_p(), cgraph_node::former_clone_of, gcc_assert, gcc_checking_assert, cgraph_node::get(), clone_info::get(), gimple_bb(), gimple_build_nop(), gimple_call_chain(), gimple_call_fndecl(), gimple_call_fntype(), gimple_call_lhs(), gimple_call_noreturn_p(), gimple_call_set_chain(), gimple_call_set_fndecl(), gimple_call_set_fntype(), gimple_call_set_lhs(), gimple_ic(), indirect_info, indirect_unknown_callee, profile_probability::initialized_p(), ipa_saved_clone_sources, ipa_verify_edge_has_no_modifications(), lookup_stmt_eh_lp(), make_direct(), maybe_remove_unused_call_args(), next_speculative_call_target(), NULL, NULL_TREE, cgraph_indirect_call_info::num_speculative_call_targets, num_speculative_call_targets_p(), clone_info::param_adjustments, pop_cfun(), print_gimple_stmt(), profile_count::probability_in(), push_cfun(), ipa_ref::referred, remove_stmt_from_eh_lp(), set_call_stmt(), cgraph_node::set_call_stmt_including_clones(), set_ssa_default_def(), SET_SSA_NAME_VAR_OR_IDENTIFIER, should_remove_lhs_p(), speculative, ipa_ref::speculative, speculative_call_indirect_edge(), speculative_call_target_ref(), SSA_NAME_DEF_STMT, ipa_ref::stmt, symtab, TREE_CODE, TREE_TYPE, TREE_VALUE, TYPE_ARG_TYPES, update_call_stmt_hash_for_removing_direct_edge(), update_stmt_fn(), void_type_node, and VOID_TYPE_P.

Referenced by autofdo::afdo_indirect_call(), create_dispatcher_calls(), function_and_variable_visibility(), inline_transform(), redirect_all_calls(), redirect_to_specific_clone(), walk_polymorphic_call_targets(), and walk_polymorphic_call_targets().

◆ redirect_callee()

◆ redirect_callee_duplicating_thunks()

void cgraph_edge::redirect_callee_duplicating_thunks ( cgraph_node * n)
If E does not lead to a thunk, simply redirect it to N.  Otherwise create
one or more equivalent thunks for N and redirect E to the first in the
chain.  Note that it is then necessary to call
n->expand_all_artificial_thunks once all callers are redirected.   

References callee, duplicate_thunk_for_node(), redirect_callee(), cgraph_node::thunk, and cgraph_node::ultimate_alias_target().

Referenced by cgraph_node::create_clone(), create_specialized_node(), and perhaps_add_new_callers().

◆ remove()

◆ remove_callee()

void cgraph_edge::remove_callee ( void )
inlineprivate
Remove the edge from the list of the callers of the callee.   

References callee, cgraph_node::callers, gcc_assert, indirect_unknown_callee, next_caller, and prev_caller.

Referenced by redirect_callee(), and cgraph_node::remove_callees().

◆ remove_caller()

◆ resolve_speculation()

cgraph_edge * cgraph_edge::resolve_speculation ( cgraph_edge * edge,
tree callee_decl = NULL )
static
Speculative call EDGE turned out to be direct call to CALLEE_DECL.  Remove
the speculative call sequence and return edge representing the call, the
original EDGE can be removed and deallocated.  Return the edge that now
represents the call.

For "speculative" indirect call that contains multiple "speculative"
targets (i.e. edge->indirect_info->num_speculative_call_targets > 1),
decrease the count and only remove current direct edge.

If no speculative direct call left to the speculative indirect call, remove
the speculative of both the indirect call and corresponding direct edge.

It is up to caller to iteratively resolve each "speculative" direct call and
redirect the call as appropriate.   

References callee, count, dump_file, symtab_node::dump_name(), first_speculative_call_target(), gcc_assert, symtab_node::get(), indirect_unknown_callee, inline_failed, print_generic_expr(), ipa_ref::referred, remove(), ipa_ref::remove_reference(), cgraph_node::remove_symbol_and_inline_clones(), symtab_node::semantically_equivalent_p(), speculative, speculative_call_target_ref(), and update_call_stmt_hash_for_removing_direct_edge().

Referenced by check_speculations_1(), inline_small_functions(), ipa_inline(), ipa_merge_profiles(), make_direct(), redirect_to_unreachable(), and resolve_noninline_speculation().

◆ set_call_stmt()

◆ set_callee()

void cgraph_edge::set_callee ( cgraph_node * n)
inlineprivate
Set callee N of call graph edge and add it to the corresponding set of
callers.  

References callee, cgraph_node::callers, next_caller, NULL, and prev_caller.

Referenced by redirect_callee().

◆ speculative_call_for_target()

cgraph_edge * cgraph_edge::speculative_call_for_target ( cgraph_node * target)
Return edge corresponding to speculative call to a given target.
NULL if speculative call does not have one.   

References first_speculative_call_target(), next_speculative_call_target(), and NULL.

Referenced by ipa_devirt(), ipa_make_edge_direct_to_target(), and ipa_merge_profiles().

◆ speculative_call_indirect_edge()

◆ speculative_call_target_ref()

◆ sreal_frequency()

◆ verify_corresponds_to_fndecl()

bool cgraph_edge::verify_corresponds_to_fndecl ( tree decl)
private

◆ verify_count()

bool cgraph_edge::verify_count ( )
Verify edge count and frequency.   

References count, error(), error_found, and profile_count::verify().

Referenced by cgraph_node::verify_node().

Friends And Related Symbol Documentation

◆ cgraph_node

friend struct cgraph_node
friend

◆ symbol_table

friend class symbol_table
friend

Field Documentation

◆ aux

void* cgraph_edge::aux

◆ call_stmt

◆ call_stmt_cannot_inline_p

unsigned int cgraph_edge::call_stmt_cannot_inline_p

◆ callee

cgraph_node* cgraph_edge::callee

Referenced by ipcp_lattice< valtype >::add_value(), binds_to_current_def_p(), ipa_icf::sem_item_optimizer::build_graph(), call_passes_through_thunk(), caller_growth_limits(), calls_same_node_or_its_all_contexts_clone_p(), can_early_inline_edge_p(), can_inline_edge_by_limits_p(), can_inline_edge_p(), cannot_lead_to_return_p(), cgraph_add_edge_to_call_site_hash(), cgraph_update_edges_for_call_stmt_node(), clone(), clone_inlined_nodes(), clone_of_p(), ipa_icf::sem_function::compare_polymorphic_p(), compute_fn_summary(), compute_ltrans_boundary(), contains_hot_call_p(), cgraph_node::create_clone(), debug(), delete_unreachable_blocks_update_callgraph(), dump_inline_stats(), duplicate_thunk_for_node(), early_inline_small_functions(), edge_set_predicate(), ipa_icf::sem_function::equals_wpa(), estimate_calls_size_and_time_1(), estimate_edge_size_and_time(), evaluate_properties_for_edge(), expand_call_inline(), expand_thunk(), first_speculative_call_target(), flatten_function(), function_and_variable_visibility(), cgraph_node::function_or_virtual_thunk_symbol(), cgraph_node::function_symbol(), get_read_write_all_from_node(), handle_missing_profiles(), ignore_edge_for_nothrow(), ignore_edge_for_pure_const(), ignore_edge_p(), ignore_edge_p(), ignore_edge_p(), initialize_inline_failed(), inline_always_inline_functions(), inline_call(), inline_update_callee_summaries(), ipa_compute_jump_functions_for_bb(), ipa_edge_within_scc(), ipa_get_callee_param_type(), ipa_make_edge_direct_to_target(), ipa_print_node_jump_functions(), ipa_profile(), ipa_propagate_indirect_call_infos(), ipa_read_edge_info(), ipa_tm_diagnose_tm_safe(), ipa_tm_transform_calls_redirect(), ipcp_discover_new_direct_edges(), cgraph_node::local_p(), lookup_recursive_calls(), make_direct(), maybe_hot_p(), merge_aggregate_lattices(), ipa_param_adjustments::modify_call(), next_speculative_call_target(), num_calls(), possibly_call_in_translation_unit_p(), propagate_aggs_across_jump_function(), propagate_bits(), propagate_bits_across_jump_function(), propagate_constants_across_call(), propagate_constants_topo(), propagate_controlled_uses(), value_topo_info< valtype >::propagate_effects(), propagate_info_to_inlined_callees(), propagate_nothrow(), propagate_pure_const(), read_ipa_call_summary(), recursive_inlining(), recursive_p(), redirect_call_stmt_to_callee(), redirect_callee(), redirect_callee_duplicating_thunks(), redirect_to_unreachable(), remap_edge_summaries(), remove_callee(), cgraph_node::remove_symbol_and_inline_clones(), symbol_table::remove_unreachable_nodes(), report_inline_failed_reason(), reset_edge_caches(), resolve_speculation(), self_recursive_agg_pass_through_p(), self_recursive_p(), self_recursive_pass_through_p(), set_call_stmt(), set_callee(), speculation_useful_p(), speculative_call_indirect_edge(), spread_undeadness(), summarize_calls_size_and_time(), try_make_edge_direct_simple_call(), update_callee_keys(), update_indirect_edges_after_inlining(), update_inlined_to_pointer(), update_noncloned_counts(), verify_corresponds_to_fndecl(), cgraph_node::verify_node(), want_early_inline_function_p(), and want_inline_small_function_p().

◆ caller

cgraph_node* cgraph_edge::caller

Referenced by adjust_callers_for_value_intersection(), adjust_clone_incoming_counts(), adjust_references_in_caller(), cgraph_node::assemble_thunks_and_aliases(), big_speedup_p(), binds_to_current_def_p(), cgraph_node::call_for_symbol_thunks_and_aliases(), caller_growth_limits(), calls_same_node_or_its_all_contexts_clone_p(), can_early_inline_edge_p(), can_inline_edge_by_limits_p(), can_inline_edge_p(), cannot_lead_to_return_p(), cgraph_add_edge_to_call_site_hash(), cgraph_edge_brings_all_scalars_for_node(), cgraph_edge_brings_value_p(), cgraph_edge_brings_value_p(), cgraph_update_edge_in_call_site_hash(), check_callers(), clone(), clone_inlined_nodes(), collect_callers_of_node_1(), create_specialized_node(), debug(), decide_whether_version_node(), do_estimate_growth_1(), ipa_edge_args_sum_t::duplicate(), duplicate_thunk_for_node(), early_inline_small_functions(), estimate_edge_devirt_benefit(), evaluate_properties_for_edge(), cgraph_node::expand_all_artificial_thunks(), expand_call_inline(), find_more_contexts_for_caller_subset(), find_more_scalar_values_for_callers_subset(), first_speculative_call_target(), flatten_function(), frequency(), function_and_variable_visibility(), function_called_by_processed_nodes_p(), gather_caller_stats(), get_info_about_necessary_edges(), handle_missing_profiles(), has_undead_caller_from_outside_scc_p(), ignore_edge_for_nothrow(), ignore_edge_for_pure_const(), ignore_edge_p(), ignore_edge_p(), ignore_edge_p(), inline_always_inline_functions(), inline_call(), inline_small_functions(), inline_to_all_callers_1(), ipa_compute_jump_functions_for_edge(), ipa_edge_within_scc(), ipa_get_indirect_edge_target_1(), ipa_get_stack_frame_offset(), ipa_impossible_devirt_target(), ipa_make_edge_direct_to_target(), ipa_merge_modref_summary_after_inlining(), ipa_tm_execute(), ipa_tm_note_irrevocable(), ipa_tm_transform_calls_redirect(), ipa_value_range_from_jfunc(), lookup_recursive_calls(), make_speculative(), maybe_hot_p(), perhaps_add_new_callers(), possibly_call_in_translation_unit_p(), ipcp_lattice< valtype >::print(), propagate_aggregate_lattice(), propagate_aggs_across_jump_function(), propagate_bits_across_jump_function(), propagate_constants_across_call(), propagate_context_across_jump_function(), propagate_controlled_uses(), value_topo_info< valtype >::propagate_effects(), propagate_nothrow(), propagate_pure_const(), propagate_scalar_across_jump_function(), propagate_vals_across_arith_jfunc(), propagate_vr_across_jump_function(), push_agg_values_for_index_from_edge(), reachable_from_other_partition_p(), reachable_from_this_partition_p(), recursive_inlining(), recursive_p(), ipa_icf::redirect_all_callers(), redirect_call_stmt_to_callee(), redirect_callee(), remove_caller(), remove_described_reference(), report_inline_failed_reason(), reset_edge_caches(), self_recursive_agg_pass_through_p(), self_recursive_pass_through_p(), set_call_stmt(), set_nothrow_flag_1(), set_single_call_flag(), speculation_useful_p(), speculative_call_indirect_edge(), speculative_call_target_ref(), sreal_frequency(), try_make_edge_direct_virtual_call(), update_call_expr(), update_call_stmt_hash_for_removing_direct_edge(), update_callee_keys(), update_indirect_edges_after_inlining(), cgraph_node::verify_node(), want_early_inline_function_p(), and want_inline_small_function_p().

◆ can_throw_external

◆ count

◆ in_polymorphic_cdtor

◆ indirect_info

◆ indirect_inlining_edge

◆ indirect_unknown_callee

◆ inline_failed

◆ lto_stmt_uid

◆ m_summary_id

int cgraph_edge::m_summary_id
private

◆ m_uid

int cgraph_edge::m_uid
private

Referenced by get_uid().

◆ next_callee

cgraph_edge* cgraph_edge::next_callee

Referenced by analyze_functions(), ipa_icf::sem_item_optimizer::build_graph(), calls_builtin_apply_args_p(), calls_builtin_va_start_p(), can_early_inline_edge_p(), can_strub_internally_p(), cgraph_node::check_calls_comdat_local_p(), clone_inlined_nodes(), clone_of_p(), ipa_icf::sem_function::compare_polymorphic_p(), compute_fn_summary(), compute_ltrans_boundary(), contains_hot_call_p(), cgraph_node::create_clone(), cgraph_node::create_version_clone(), determine_versionability(), devirtualization_time_bonus(), drop_profile(), dump_inline_stats(), dump_ipa_call_summary(), dump_modref_edge_summaries(), dump_profile_updates(), ipa_fn_summary_t::duplicate(), early_inline_small_functions(), early_inliner(), ipa_icf::sem_function::equals_wpa(), estimate_calls_size_and_time(), estimate_calls_size_and_time_1(), first_speculative_call_target(), fixup_call_stmt_edges_1(), flatten_function(), function_and_variable_visibility(), cgraph_node::get_edge(), get_read_write_all_from_node(), initialize_node_lattices(), inline_always_inline_functions(), inline_analyze_function(), inline_call(), inline_read_section(), inline_small_functions(), inline_transform(), inline_update_callee_summaries(), input_node_opt_summary(), ipa_analyze_node(), ipa_devirt(), ipa_fn_summary_write(), ipa_inline(), ipa_merge_profiles(), ipa_print_node_jump_functions(), ipa_profile(), ipa_profile_dump_all_summaries(), ipa_profile_read_summary_section(), ipa_profile_write_summary(), ipa_read_node_info(), ipa_tm_diagnose_tm_safe(), ipa_write_node_info(), ipcp_discover_new_direct_edges(), ipcp_propagate_stage(), localize_profile(), lookup_recursive_calls(), mark_all_inlined_calls_cdtor(), maybe_materialize_called_clones(), merge_profile_summaries(), next_speculative_call_target(), num_calls(), optimize_inline_calls(), output_node_opt_summary(), propagate_bits(), propagate_constants_topo(), propagate_info_to_inlined_callees(), propagate_malloc(), propagate_nothrow(), propagate_pure_const(), recursive_inlining(), ipa_icf::redirect_all_callers(), redirect_to_specific_clone(), remap_edge_summaries(), cgraph_node::remove_callees(), ipa_fn_summary_t::remove_callees(), remove_caller(), remove_modref_edge_summaries(), cgraph_node::remove_symbol_and_inline_clones(), symbol_table::remove_unreachable_nodes(), reset_edge_caches(), scale_ipa_profile_for_fn(), searchc(), self_recursive_p(), speculative_call_indirect_edge(), spread_undeadness(), summarize_calls_size_and_time(), ipa_icf::symbol_compare_collection::symbol_compare_collection(), tree_function_versioning(), update_call_stmt_hash_for_removing_direct_edge(), update_callee_keys(), update_counts_for_self_gen_clones(), update_indirect_edges_after_inlining(), update_inlined_to_pointer(), update_noncloned_counts(), update_profiling_info(), update_specialized_profile(), cgraph_node::verify_node(), verify_speculative_call(), and verify_strub().

◆ next_caller

cgraph_edge* cgraph_edge::next_caller

◆ prev_callee

◆ prev_caller

cgraph_edge* cgraph_edge::prev_caller

◆ speculative

◆ speculative_id

unsigned int cgraph_edge::speculative_id

The documentation for this class was generated from the following files: