GCC Middle and Back End API Reference
function.h File Reference

Go to the source code of this file.

Data Structures

struct  sequence_stack
 
struct  emit_status
 
struct  expr_status
 
struct  rtl_eh
 
struct  varasm_status
 
struct  function_subsections
 
class  frame_space
 
struct  callinfo_callee
 
struct  callinfo_dalloc
 
class  stack_usage
 
struct  function
 
struct  types_used_by_vars_entry
 
struct  used_type_hasher
 
struct  args_size
 
struct  locate_and_pad_arg_data
 

Macros

#define reg_rtx_no   (crtl->emit.x_reg_rtx_no)
 
#define REGNO_POINTER_ALIGN(REGNO)   (crtl->emit.regno_pointer_align[REGNO])
 
#define pending_stack_adjust   (crtl->expr.x_pending_stack_adjust)
 
#define inhibit_defer_pop   (crtl->expr.x_inhibit_defer_pop)
 
#define saveregs_value   (crtl->expr.x_saveregs_value)
 
#define apply_args_value   (crtl->expr.x_apply_args_value)
 
#define forced_labels   (crtl->expr.x_forced_labels)
 
#define stack_pointer_delta   (crtl->expr.x_stack_pointer_delta)
 
#define current_function_static_stack_size   (cfun->su->static_stack_size)
 
#define current_function_dynamic_stack_size   (cfun->su->dynamic_stack_size)
 
#define current_function_pushed_stack_size   (cfun->su->pushed_stack_size)
 
#define current_function_has_unbounded_dynamic_stack_size    (cfun->su->has_unbounded_dynamic_stack_size)
 
#define current_function_allocates_dynamic_stack_space
 
#define FOR_EACH_LOCAL_DECL(FUN, I, D)    FOR_EACH_VEC_SAFE_ELT_REVERSE ((FUN)->local_decls, I, D)
 
#define VA_LIST_MAX_GPR_SIZE   255
 
#define VA_LIST_MAX_FPR_SIZE   255
 
#define cfun   (cfun + 0)
 
#define current_function_funcdef_no   (cfun->funcdef_no)
 
#define current_loops   (cfun->x_current_loops)
 
#define dom_computed   (cfun->cfg->x_dom_computed)
 
#define n_bbs_in_dom_tree   (cfun->cfg->x_n_bbs_in_dom_tree)
 
#define VALUE_HISTOGRAMS(fun)   (fun)->value_histograms
 
#define ADD_PARM_SIZE(TO, INC)
 
#define SUB_PARM_SIZE(TO, DEC)
 
#define ARGS_SIZE_TREE(SIZE)
 
#define ARGS_SIZE_RTX(SIZE)
 
#define ASLK_REDUCE_ALIGN   1
 
#define ASLK_RECORD_PAD   2
 
#define MINIMUM_METHOD_BOUNDARY
 

Typedefs

typedef struct call_site_record_dcall_site_record
 

Enumerations

enum  stack_clash_probes { NO_PROBE_NO_FRAME , NO_PROBE_SMALL_FRAME , PROBE_INLINE , PROBE_LOOP }
 

Functions

void add_local_decl (struct function *fun, tree d)
 
void record_final_call (tree callee, location_t location)
 
void record_dynamic_alloc (tree decl_or_exp)
 
void types_used_by_var_decl_insert (tree type, tree var_decl)
 
struct loopsloops_for_fn (struct function *fn)
 
void set_loops_for_fn (struct function *fn, struct loops *loops)
 
unsigned short get_new_clique (function *fn)
 
void dump_stack_clash_frame_info (enum stack_clash_probes, bool)
 
void push_function_context (void)
 
void pop_function_context (void)
 
void free_after_parsing (struct function *)
 
void free_after_compilation (struct function *)
 
poly_int64 get_frame_size (void)
 
bool frame_offset_overflow (poly_int64, tree)
 
unsigned int spill_slot_alignment (machine_mode)
 
rtx assign_stack_local_1 (machine_mode, poly_int64, int, int)
 
rtx assign_stack_local (machine_mode, poly_int64, int)
 
rtx assign_stack_temp_for_type (machine_mode, poly_int64, tree)
 
rtx assign_stack_temp (machine_mode, poly_int64)
 
rtx assign_temp (tree, int, int)
 
void update_temp_slot_address (rtx, rtx)
 
void preserve_temp_slots (rtx)
 
void free_temp_slots (void)
 
void push_temp_slots (void)
 
void pop_temp_slots (void)
 
void init_temp_slots (void)
 
rtx get_hard_reg_initial_reg (rtx)
 
rtx get_hard_reg_initial_val (machine_mode, unsigned int)
 
rtx has_hard_reg_initial_val (machine_mode, unsigned int)
 
void emit_initial_value_sets (void)
 
bool initial_value_entry (int i, rtx *, rtx *)
 
void instantiate_decl_rtl (rtx x)
 
bool aggregate_value_p (const_tree, const_tree)
 
bool use_register_for_decl (const_tree)
 
gimple_seq gimplify_parameters (gimple_seq *)
 
void locate_and_pad_parm (machine_mode, tree, int, int, int, tree, struct args_size *, struct locate_and_pad_arg_data *)
 
void generate_setjmp_warnings (void)
 
void reorder_blocks (void)
 
void clear_block_marks (tree)
 
tree blocks_nreverse (tree)
 
tree block_chainon (tree, tree)
 
void number_blocks (tree)
 
void set_cfun (struct function *new_cfun, bool force=false)
 
void push_cfun (struct function *new_cfun)
 
void pop_cfun (void)
 
int get_next_funcdef_no (void)
 
int get_last_funcdef_no (void)
 
void allocate_struct_function (tree, bool)
 
void push_struct_function (tree fndecl, bool=false)
 
void push_dummy_function (bool)
 
void pop_dummy_function (void)
 
void init_dummy_function_start (void)
 
void init_function_start (tree)
 
void stack_protect_epilogue (void)
 
void expand_function_start (tree)
 
void expand_dummy_function_end (void)
 
void thread_prologue_and_epilogue_insns (void)
 
void diddle_return_value (void(*)(rtx, void *), void *)
 
void clobber_return_register (void)
 
void expand_function_end (void)
 
rtx get_arg_pointer_save_area (void)
 
void maybe_copy_prologue_epilogue_insn (rtx, rtx)
 
bool prologue_contains (const rtx_insn *)
 
bool epilogue_contains (const rtx_insn *)
 
bool prologue_epilogue_contains (const rtx_insn *)
 
void record_prologue_seq (rtx_insn *)
 
void record_epilogue_seq (rtx_insn *)
 
void emit_return_into_block (bool simple_p, basic_block bb)
 
void set_return_jump_label (rtx_insn *)
 
bool active_insn_between (rtx_insn *head, rtx_insn *tail)
 
vec< edgeconvert_jumps_to_returns (basic_block last_bb, bool simple_p, vec< edge > unconverted)
 
basic_block emit_return_for_exit (edge exit_fallthru_edge, bool simple_p)
 
void reposition_prologue_and_epilogue_notes (void)
 
poly_int64 get_stack_dynamic_offset ()
 
const charfndecl_name (tree)
 
const charfunction_name (const function *)
 
const charcurrent_function_name (void)
 
void used_types_insert (tree)
 

Variables

rtxregno_reg_rtx
 
struct functioncfun
 
int virtuals_instantiated
 
int trampolines_created
 
hash_table< used_type_hasher > * types_used_by_vars_hash
 
vec< tree, va_gc > * types_used_by_cur_var_decl
 
struct machine_function *(* init_machine_status )(void)
 
bool currently_expanding_function_start
 

Macro Definition Documentation

◆ ADD_PARM_SIZE

#define ADD_PARM_SIZE ( TO,
INC )
Value:
do { \
tree inc = (INC); \
(TO).constant += tree_to_shwi (inc); \
else if ((TO).var == 0) \
(TO).var = fold_convert (ssizetype, inc); \
else \
(TO).var = size_binop (PLUS_EXPR, (TO).var, \
} while (0)
union tree_node * tree
Definition coretypes.h:97
#define size_binop(CODE, T1, T2)
Definition fold-const.h:187
#define fold_convert(T1, T2)
Definition fold-const.h:92
T * ggc_alloc(ALONE_CXX_MEM_STAT_INFO)
Definition ggc.h:184
bool tree_fits_shwi_p(const_tree t)
Definition tree.cc:6399
HOST_WIDE_INT tree_to_shwi(const_tree t)
Definition tree.cc:6460
#define ssizetype
Definition tree.h:5104
Add the value of the tree INC to the `struct args_size' TO.   

Referenced by assign_parm_is_stack_parm(), initialize_argument_information(), locate_and_pad_parm(), and pad_below().

◆ apply_args_value

#define apply_args_value   (crtl->expr.x_apply_args_value)

◆ ARGS_SIZE_RTX

#define ARGS_SIZE_RTX ( SIZE)
Value:
((SIZE).var == 0 ? gen_int_mode ((SIZE).constant, Pmode) \
rtx gen_int_mode(poly_int64 c, machine_mode mode)
Definition emit-rtl.cc:544
rtx expand_normal(tree exp)
Definition expr.h:320
#define ARGS_SIZE_TREE(SIZE)
Definition function.h:610
Convert the implicit sum in a `struct args_size' into an rtx.   

Referenced by assign_parm_find_stack_rtl(), assign_parms(), compute_argument_addresses(), emit_library_call_value_1(), expand_call(), and store_one_arg().

◆ ARGS_SIZE_TREE

#define ARGS_SIZE_TREE ( SIZE)
Value:
((SIZE).var == 0 ? ssize_int ((SIZE).constant) \
ssize_int ((SIZE).constant)))
#define ssize_int(L)
Definition tree.h:5107
Convert the implicit sum in a `struct args_size' into a tree
of type ssizetype.   

Referenced by compute_argument_block_size(), locate_and_pad_parm(), and pad_to_arg_alignment().

◆ ASLK_RECORD_PAD

#define ASLK_RECORD_PAD   2

◆ ASLK_REDUCE_ALIGN

#define ASLK_REDUCE_ALIGN   1

◆ cfun

#define cfun   (cfun + 0)
In order to ensure that cfun is not set directly, we redefine it so
that it is not an lvalue.  Rather than assign to cfun, use
push_cfun or set_cfun.   

Referenced by _succ_iter_cond(), _succ_iter_start(), add_autoinc_candidates(), add_cfis_to_fde(), add_control_edge(), add_ehspec_entry(), add_exit_phis(), add_exit_phis_var(), add_labels_and_missing_jumps(), add_loop(), cgraph_node::add_new_function(), add_noreturn_fake_exit_edges(), add_other_self_distances(), infer_range_manager::add_range(), add_ranges_and_copies(), add_scope_conflicts(), add_stmt_to_eh_lp(), add_ttypes_entry(), addr_object_size(), adjust_cfg_counts(), strlen_pass::adjust_last_stmt(), autofdo::afdo_annotate_cfg(), autofdo::afdo_calculate_branch_prob(), autofdo::afdo_find_equiv_class(), autofdo::afdo_indirect_call(), autofdo::afdo_propagate(), autofdo::afdo_propagate_circuit(), autofdo::afdo_propagate_edge(), autofdo::afdo_vpt_for_early_inline(), alloc_aux_for_blocks(), alloc_aux_for_edges(), alloc_cluster_vectors(), alloc_gcse_mem(), alloc_mem(), alloc_stack_frame_space(), alloca_call_type(), allocate_dynamic_stack_space(), allocate_initial_values(), allocate_stack_usage_info(), allocate_struct_function(), cgraph_node::analyze(), analyze_all_variable_accesses(), analyze_function(), analyze_function_body(), analyze_memory_references(), tree_switch_conversion::switch_decision_tree::analyze_switch_statement(), fixup_note_insn_basic_block::apply(), apply_args_size(), apply_clusters(), apply_opt_in_copies(), apply_return_prediction(), assemble_function_label_final(), assemble_start_function(), assign_discriminators(), assign_filter_values(), assign_parm_find_data_types(), assign_parm_setup_block(), assign_parms(), assign_parms_augmented_arg_list(), assign_spill_hard_regs(), associate_equivalences_with_edges(), assume_query::assume_query(), avoid_folding_inline_builtin(), based_loc_descr(), rt_bb_visited::bb2idx(), bb_has_well_behaved_predecessors(), bb_is_just_return(), bb_loop_header_p(), bb_to_key(), loop_distribution::bb_top_order_init(), find_comparison_dom_walker::before_dom_children(), find_candidates_dom_walker::before_dom_children(), substitute_and_fold_dom_walker::before_dom_children(), better_edge_p(), bitmap_intersection_of_preds(), bitmap_intersection_of_succs(), bitmap_union_of_preds(), bitmap_union_of_succs(), block_before_loop(), block_has_only_trap(), block_label(), ranger_cache::block_range(), bound_difference(), branch_prob(), break_superblocks(), brief_dump_cfg(), build_and_add_sum(), build_call_internal(), build_classic_dist_vector_1(), tree_switch_conversion::switch_conversion::build_constructors(), build_duplicate_type(), build_gimple_cfg(), build_insn_chain(), build_omp_regions(), tree_switch_conversion::switch_conversion::build_one_array(), build_ssa_conflict_graph(), build_store_vectors(), builtin_setjmp_setup_bb(), bypass_block(), bypass_conditional_jumps(), cached_make_edge(), gimple_outgoing_range::calc_switch_ranges(), calculate_bb_reg_pressure(), calculate_dominance_info(), calculate_elim_costs_all_insns(), calculate_equiv_gains(), calculate_gen_cands(), calculate_global_remat_bb_data(), gori_map::calculate_gori(), calculate_live_on_exit(), calculate_livein_cands(), calculate_local_reg_remat_bb_data(), calculate_loop_reg_pressure(), call_can_make_abnormal_goto(), can_delete_call(), can_duplicate_block_p(), can_eliminate_compare(), can_fallthru(), jt_path_registry::cancel_invalid_paths(), canonicalize_induction_variables(), canonicalize_math_after_vectorization_p(), canonicalize_math_p(), canonicalize_math_p(), ccp_finalize(), ccp_initialize(), cfg_layout_can_merge_blocks_p(), cfg_layout_delete_block(), cfg_layout_duplicate_bb(), cfg_layout_redirect_edge_and_branch(), cfg_layout_split_edge(), cfun_returns(), cgraph_build_static_cdtor_1(), cgraph_debug_gimple_stmt(), cgraph_update_edges_for_call_stmt(), cheap_bb_rtx_cost_p(), rt_bb_visited::check(), check_all_va_list_escapes(), check_bool_pattern(), check_bounds_or_overlap(), check_call(), tree_switch_conversion::switch_conversion::check_final_bb(), check_nul_terminated_array(), check_omp_nesting_restrictions(), check_rtl(), check_stmt(), chrec_component_in_loop_num(), chrec_contains_symbols_defined_in_loop(), chrec_evaluate(), clean_up_after_unswitching(), cleanup_all_empty_eh(), cleanup_control_flow_bb(), cleanup_control_flow_pre(), cleanup_dead_labels(), cleanup_dead_labels_eh(), cleanup_empty_eh(), cleanup_tree_cfg_noloop(), clear_aux_for_blocks(), clear_aux_for_edges(), clear_bb_flags(), clear_pending_stack_adjust(), clear_special_calls(), clear_unused_block_pointer(), coalesce_cost_bb(), coalesce_partitions(), coalesce_with_default(), tree_switch_conversion::switch_conversion::collect(), collect_dfa_stats(), combine_and_move_insns(), combine_instructions(), combine_reloads(), combine_stack_adjustments(), commit_edge_insertions(), commit_one_edge_insertion(), compact_blocks(), compute_alignments(), compute_antic(), compute_antinout_edge(), compute_available(), compute_bb_for_insn(), compute_branch_probabilities(), tree_switch_conversion::switch_decision_tree::compute_cases_per_edge(), compute_code_hoist_vbeinout(), compute_control_dep_chain_pdom(), compute_cprop_data(), compute_dependence_clique(), compute_dom_fast_query(), compute_dominance_frontiers(), compute_earliest(), compute_farthest(), compute_function_frequency(), compute_hash_table(), compute_hash_table_work(), compute_hash_table_work(), compute_idf(), compute_insert_delete(), compute_laterin(), compute_ld_motion_mems(), compute_live_loop_exits(), compute_local_properties(), compute_local_properties(), compute_may_aliases(), compute_nearerout(), compute_points_to_sets(), compute_pre_data(), compute_regs_asm_clobbered(), compute_rev_insert_delete(), compute_store_table(), compute_transaction_bits(), compute_uninit_opnds_pos(), compute_value_histograms(), cond_exec_find_if_block(), cond_if_else_store_replacement_1(), cond_store_replacement(), connect_better_edge_p(), connect_infinite_loops_to_exit(), connect_traces(), connect_traces(), consider_split(), construct_exit_block(), construct_init_block(), vect_optimize_slp_pass::containing_loop(), contains_no_active_insn_p(), control_dependences::control_dependences(), control_flow_insn_p(), convert_cfa_to_fb_loc_list(), convert_mult_to_fma_1(), convert_single_case_switch(), convert_to_divmod(), copy_bb(), copy_bb(), copy_cfg_body(), copy_edges_for_bb(), copy_gimple_seq_and_replace_locals(), copy_loops(), copy_phi_node_args(), copy_reference_ops_from_call(), copy_reference_ops_from_ref(), copy_ssa_name(), correct_negative_edge_counts(), could_fall_through(), count_reg_usage(), coverage_begin_function(), coverage_end_function(), cprop_jump(), create_assumption_fn(), create_basic_block_structure(), create_bb(), create_coalesce_list_for_region(), create_default_def(), create_edge_list(), function_reader::create_edges(), create_eh_forwarder_block(), create_fixup_graph(), function_reader::create_function(), create_log_links(), create_loop_fn(), create_loop_tree_nodes(), create_new_def_for(), create_omp_child_function(), create_parallel_loop(), create_preheader(), create_preheaders(), create_remat_bb_data(), create_tmp_reg_or_ssa_name(), create_trace_edges(), cse_cc_succs(), cse_condition_code_reg(), cse_extended_basic_block(), cse_find_path(), cse_insn(), cse_main(), ctor_for_folding(), current_function_has_exception_handlers(), current_function_name(), dbr_schedule(), dead_or_predicable(), profile_count::debug(), debug_bb_n(), debug_bb_n(), debug_bb_n_slim(), debug_dominance_info(), debug_loop_num(), debug_seed_ranger(), decide_copy_try_finally(), decide_unrolling(), declare_inline_vars(), decompose_multiword_subregs(), decrease_live_ranges_number(), deletable_insn_p(), delete_dead_jumptables(), delete_noop_moves(), delete_unmarked_insns(), delete_unreachable_blocks(), delete_unreachable_blocks_update_callgraph(), delete_vta_debug_insns(), delink_stmt_imm_use(), determine_dominators_for_sons(), determine_scaling_factor(), determine_unlikely_bbs(), determine_value_range(), df_analyze(), df_bb_delete(), df_bb_refs_record(), df_bb_replace(), df_chain_create_bb(), df_chain_remove_problem(), df_compact_blocks(), df_dump(), df_dump_region(), df_entry_block_defs_collect(), df_exit_block_uses_collect(), df_grow_bb_info(), df_insn_rescan_all(), df_live_bb_local_compute(), df_live_set_all_dirty(), df_live_verify_solution_end(), df_live_verify_solution_start(), df_live_verify_transfer_functions(), df_lr_bb_local_compute(), df_lr_confluence_0(), df_lr_verify_solution_end(), df_lr_verify_solution_start(), df_lr_verify_transfer_functions(), df_md_bb_local_compute(), df_md_local_compute(), df_md_transfer_function(), df_mir_bb_local_compute(), df_mir_verify_solution_end(), df_mir_verify_solution_start(), df_note_bb_compute(), df_rd_bb_local_compute(), df_record_entry_block_defs(), df_record_exit_block_uses(), df_reorganize_refs_by_insn(), df_reorganize_refs_by_reg_by_insn(), df_scan_alloc(), df_scan_blocks(), df_scan_start_dump(), df_scan_verify(), df_set_blocks(), df_update_entry_block_defs(), df_update_entry_exit_and_calls(), df_update_exit_block_uses(), df_word_lr_alloc(), df_word_lr_bb_local_compute(), df_worklist_dataflow(), df_worklist_dataflow_doublequeue(), df_worklist_propagate_backward(), df_worklist_propagate_forward(), dfs_enumerate_from(), diag_returned_locals(), disambiguate_loops_with_multiple_latches(), disambiguate_multiple_latches(), discover_loop(), discover_loops(), discover_nonconstant_array_refs(), disqualify_problematic_components(), distribute_links(), distribute_notes(), do_per_function(), do_per_function_toporder(), do_reassoc(), do_reload(), do_remat(), do_rpo_vn_1(), do_tablejump(), do_warn_aggressive_loop_optimizations(), doloop_optimize_loops(), dom_info_available_p(), dom_info_state(), dom_oracle::dom_oracle(), dom_ranger::dom_ranger(), dominated_by_forbidden(), dr_step_indicator(), draw_cfg_nodes(), draw_cfg_nodes_for_loop(), dse_optimize_call(), dse_step0(), dse_step1(), dse_step3(), dse_step4(), dse_step5(), dse_step6(), ssa_block_ranges::dump(), gori_map::dump(), dom_oracle::dump(), equiv_oracle::dump(), gimple_ranger::dump(), dump_alias_info(), dump_bb_info(), dump_candidates_and_remat_bb_data(), dump_cfg_stats(), dump_dataflow_sets(), dump_edge_info(), dump_enumerated_decls(), dump_final_node_vcg(), dump_flow_info(), dump_gimple_switch(), dump_ic_profile(), dump_immediate_uses(), dump_live_info(), dump_one_pass(), dump_stack_clash_frame_info(), dump_strlen_info(), dump_update_ssa(), dump_variable(), duplicate_eh_regions(), duplicate_insn_chain(), duplicate_loop(), duplicate_ssa_name(), dw2_build_landing_pads(), dw_loc_list(), dwarf2out_alloc_current_fde(), dwarf2out_begin_prologue(), dwarf2out_end_epilogue(), dwarf2out_frame_debug(), dwarf2out_frame_debug_expr(), dwarf2out_switch_text_section(), dwarf2out_vms_begin_epilogue(), dwarf2out_vms_end_prologue(), autofdo::early_inline(), rpo_elim::eliminate_avail(), eliminate_dom_walker::eliminate_cleanup(), eliminate_partially_redundant_load(), eliminate_partially_redundant_loads(), eliminate_dom_walker::eliminate_stmt(), eliminate_tail_call(), eliminate_unnecessary_stmts(), eliminate_useless_phis(), eliminate_with_rpo_vn(), emergency_dump_function(), tree_switch_conversion::jump_table_cluster::emit(), tree_switch_conversion::bit_test_cluster::emit(), emit_call_1(), emit_cmp_and_jump_insn_1(), emit_common_heads_for_components(), emit_common_tails_for_components(), emit_input_reload_insns(), emit_insn_at_entry(), emit_libcall_block_1(), emit_moves(), emit_output_reload_insns(), end_recording_case_labels(), entered_from_non_parent_p(), entry_of_function(), ranger_cache::entry_range(), same_succ::equal(), equiv_oracle::equiv_oracle(), estimate_bb_frequencies(), estimate_loops(), estimate_reg_pressure_cost(), evaluate_bbs(), evaluate_control_stmt_using_entry_checks(), evolution_function_is_invariant_rec_p(), evolution_function_is_univariate_p(), loop_distribution::execute(), execute_all_ipa_transforms(), execute_cleanup_eh_1(), execute_early_expand_coro_ifns(), gcc::pass_manager::execute_early_local_passes(), execute_expand_omp(), execute_fixup_cfg(), execute_function_todo(), execute_ipa_pass_list(), execute_ipa_stmt_fixups(), execute_ipa_summary_passes(), execute_oacc_device_lower(), execute_omp_device_lower(), execute_omp_oacc_neuter_broadcast(), execute_one_ipa_transform_pass(), execute_one_pass(), execute_pass_list(), execute_pass_list_1(), gcc::pass_manager::execute_pass_mode_switching(), execute_ranger_vrp(), execute_split_functions(), execute_split_paths(), execute_tm_mark(), execute_todo(), execute_update_addresses_taken(), ranger_cache::exit_range(), exp_equiv_p(), cgraph_node::expand(), expand_addsub_overflow(), expand_asm_stmt(), expand_assignment(), expand_block_edges(), expand_builtin_apply(), expand_builtin_apply_args_1(), expand_builtin_eh_common(), expand_builtin_setjmp_setup(), expand_builtin_va_copy(), expand_call(), expand_call_inline(), expand_call_stmt(), expand_call_tm(), expand_case(), expand_complex_libcall(), expand_complex_multiplication(), expand_dummy_function_end(), expand_function_end(), expand_function_start(), expand_gimple_basic_block(), expand_gimple_stmt(), expand_gimple_stmt_1(), expand_gimple_tailcall(), expand_mul_overflow(), expand_neg_overflow(), expand_oacc_for(), expand_omp_atomic(), expand_omp_atomic_fetch_op(), expand_omp_atomic_pipeline(), expand_omp_for_generic(), expand_omp_for_init_counts(), expand_omp_for_init_vars(), expand_omp_for_static_chunk(), expand_omp_for_static_nochunk(), expand_omp_simd(), expand_omp_target(), expand_omp_taskreg(), expand_parallel_call(), expand_phi_nodes(), expand_stack_alignment(), expand_thunk(), expand_used_vars(), expand_vector_operations(), expensive_function_p(), expr_not_equal_to(), expr_to_aff_combination(), expunge_block(), factor_out_conditional_operation(), fast_dce(), fill_always_executed_in(), ranger_cache::fill_block_cache(), final_1(), final_scan_insn_1(), finalize_sccopy(), finalize_task_copyfn(), find_basic_block(), find_bb_boundaries(), find_bbs_reachable_by_hot_paths(), find_best_predecessor(), find_clusters_1(), find_comparisons(), control_dependences::find_control_dependence(), find_costs_and_classes(), find_dummy_reload(), find_explicit_erroneous_behavior(), find_gang_private_vars(), find_givs_in_stmt_scev(), find_hard_regno_for_1(), find_if_case_1(), find_implicit_erroneous_behavior(), find_implicit_sets(), find_interesting_uses(), find_local_vars_to_propagate(), find_loop_location(), find_many_sub_basic_blocks(), find_moveable_pseudos(), find_moveable_store(), find_obviously_necessary_stmts(), find_partition_fixes(), find_path(), find_rarely_executed_basic_blocks_and_crossing_edges(), find_removable_extensions(), find_replaceable_exprs(), find_return_bb(), find_same_succ(), find_spanning_tree(), find_split_points(), find_sub_basic_blocks(), find_tail_calls(), find_taken_edge_computed_goto(), back_threader::find_taken_edge_switch(), find_taken_edge_switch_expr(), find_trace(), find_traces(), find_traces_1_round(), find_unreachable_blocks(), find_unswitching_predicates_for_bb(), find_uses_to_rename(), find_var_candidates(), find_var_cmp_const(), fini_copy_prop(), fini_pre(), fini_reassoc(), fini_separate_shrink_wrap(), fini_ssa_renamer(), finish_eh_generation(), finish_live_solver(), finish_remat_bb_data(), finite_function_p(), fix_bb_placement(), fix_bb_placements(), fix_crossing_conditional_branches(), fix_crossing_unconditional_branches(), fix_loop_structure(), fix_up_fall_thru_edges(), fixup_abnormal_edges(), fixup_fallthru_exit_predecessor(), fixup_new_cold_bb(), fixup_noreturn_call(), fixup_partition_crossing(), fixup_partitions(), fixup_reorder_chain(), flow_bb_inside_loop_p(), flow_loops_cfg_dump(), flow_loops_dump(), flow_loops_find(), flush_ssaname_freelist(), fold_builtin_alloca_with_align(), fold_builtin_atomic_compare_exchange(), fold_builtin_constant_p(), fold_marked_statements(), cfn_constant_float_p::fold_range(), cfn_constant_p::fold_range(), fold_truth_andor_1(), for_all_parms(), for_each_eh_label(), force_edge_cold(), force_gimple_operand_1(), force_labels_r(), force_nonfallthru_and_redirect(), force_one_exit_fallthru(), force_single_succ_latches(), form_loop_tree(), free_all_edge_infos(), free_dominance_info(), free_resource_info(), fur_source::fur_source(), fwprop_init(), gate_oacc_kernels(), gate_tm_init(), tree_switch_conversion::switch_conversion::gather_default_values(), gather_scalar_reductions(), gcse_after_reload_main(), gcse_or_cprop_is_too_expensive(), gen_eh_landing_pad(), gen_eh_region(), gen_parallel_loop(), gen_rtx_REG(), gen_tmp_stack_mem(), generate_setjmp_warnings(), get_all_stmt_may_generate_copy(), get_bb_copy(), get_bb_original(), get_bb_regions_instrumented(), get_cases_for_edge(), get_chrec_loop(), get_component_ssa_name(), autofdo::autofdo_source_profile::get_count_info(), control_dependences::get_edge_dest(), control_dependences::get_edge_src(), get_eh_landing_pad_from_number(), get_eh_region_and_lp_from_rtx(), get_eh_region_from_lp_number(), get_eh_region_from_number(), get_exec_counts(), ranger_cache::get_global_range(), get_last_alloca_addr(), get_last_value(), get_last_value_validate(), strlen_pass::get_len_or_size(), get_loop_body(), get_loop_body_in_bfs_order(), get_loop_body_in_dom_order(), get_loop_body_in_if_conv_order(), get_loop_copy(), get_loop_exit_edges(), get_loop_exit_edges_unique_dests(), get_non_trapping(), get_omp_data_i_param(), get_range(), get_range_global(), get_reaching_def(), get_ref_base_and_extent(), get_repl_default_def_ssa_name(), get_scaled_computation_cost_at(), get_size_range(), gimple_account_profile_record(), gimple_add_tmp_var(), gimple_build_debug_begin_stmt(), gimple_build_debug_inline_entry(), gimple_build_vector(), gimple_build_vector_from_val(), gimple_can_merge_blocks_p(), gimple_copy(), gimple_debug_bb_n(), gimple_divmod_fixed_value_transform(), gimple_divmod_values_to_profile(), gimple_dump_cfg(), gimple_duplicate_bb(), gimple_duplicate_loop_body_to_header_edge(), gimple_duplicate_sese_tail(), gimple_expand_builtin_pow(), gimple_expand_builtin_powi(), gimple_find_edge_insert_loc(), gimple_find_sub_bbs(), gimple_find_values_to_profile(), gimple_flow_call_edges_add(), gimple_fold_builtin_clear_padding(), gimple_fold_builtin_fputs(), gimple_fold_builtin_stpcpy(), gimple_fold_builtin_strchr(), gimple_fold_builtin_strcpy(), gimple_fold_call(), gimple_gen_ic_func_profiler(), gimple_gen_time_profiler(), gimple_ic(), gimple_indirect_call_to_profile(), gimple_lower_bitint(), gimple_mod_pow2_value_transform(), gimple_mod_subtract_transform(), gimple_predict_edge(), gimple_purge_all_dead_abnormal_call_edges(), gimple_purge_all_dead_eh_edges(), gimple_purge_dead_eh_edges(), gimple_ranger::gimple_ranger(), gimple_redirect_edge_and_branch(), gimple_regimplify_operands(), gimple_set_bb(), gimple_stringop_fixed_value(), gimple_stringops_transform(), gimple_stringops_values_to_profile(), gimple_value_profile_transformations(), gimple_verify_flow_info(), gimplify_and_update_call_from_tree(), gimplify_bind_expr(), gimplify_body(), gimplify_call_expr(), gimplify_cond_expr(), gimplify_expr(), gimplify_function_tree(), gimplify_init_constructor(), gimplify_modify_expr(), gimplify_omp_loop(), gimplify_save_expr(), gimplify_size_expressions(), gimplify_va_arg_expr(), gori_map::gori_map(), group_case_labels(), group_case_labels_stmt(), sbr_vector::grow(), gsi_commit_edge_inserts(), gsi_insert_finally_seq_after_call(), gsi_prev_dom_bb_nondebug(), gsi_remove(), gsi_replace(), gsi_replace_with_seq_vops(), handle_builtin_alloca(), strlen_pass::handle_integral_assign(), handle_simple_exit(), strlen_pass::handle_store(), has_nonexceptional_receiver(), has_nonexceptional_receiver(), hashable_expr_equal_p(), hide_evolution_in_other_loops_than_loop(), hoist_adjacent_loads(), hoist_code(), if_convert(), if_convertible_loop_p_1(), ifcvt_can_hoist(), improve_allocation(), in_loop_p(), indirect_jump_optimize(), indirect_refs_may_alias_p(), infer_loop_bounds_from_signedness(), infer_range_manager::infer_range_manager(), inherit_reload_reg(), virtual_operand_live::init(), init_alias_analysis(), init_copy_prop(), init_dont_simulate_again(), init_eh_for_function(), init_elimination(), init_empty_tree_cfg(), predicate::init_from_control_deps(), uninit_analysis::init_from_phi_def(), init_lowered_empty_function(), init_parameter_lattice_values(), init_pre(), init_reassoc(), init_resource_info(), init_separate_shrink_wrap(), init_ssa_renamer(), init_subregs_of_mode(), uninit_analysis::init_use_preds(), init_var_map(), init_worklist(), initialize_ao_ref_for_dse(), initialize_cfun(), initialize_constant_pool_replacements(), initialize_inlined_parameters(), initialize_parameter_reductions(), initialize_root_vars_store_elim_2(), initialize_uninitialized_regs(), initiate_live_solver(), inline_call(), inline_transform(), inner_loop_header_p(), input_bb(), input_cfg(), input_function(), input_ssa_names(), insert(), insert_backedge_copies(), rt_bb_visited::insert_exit_check_on_edge(), insert_into_preds_of_block(), insert_one_insn(), insert_phi_nodes(), insert_phi_nodes_for(), insert_prologue_epilogue_for_components(), insert_section_boundary_note(), insert_store(), insert_updated_phi_nodes_for(), insn_could_throw_p(), insn_live_p(), instantiate_decls(), instrument_edges(), instrument_func_entry(), instrument_func_exit(), instrument_memory_accesses(), internal_get_tmp_var(), inverted_rev_post_order_compute(), ipa_analyze_node(), ipa_compute_jump_functions_for_edge(), ipa_pta_execute(), ipa_read_optimization_summaries_1(), ipa_read_summaries_1(), ipa_simd_modify_function_body(), ipa_simd_modify_stmt_ops(), ipa_tm_scan_irr_function(), ipa_tm_transform_clone(), ipa_write_optimization_summaries_1(), ipa_write_summaries_2(), ipcp_transform_function(), ira(), ira_build(), ira_emit(), ira_loop_tree_body_rev_postorder(), ira_setup_eliminable_regset(), is_ctrl_altering_stmt(), is_division_by(), is_division_by_square(), is_inconsistent(), iterate_fix_dominators(), iv_can_overflow_p(), label_to_block(), last_bb_in_partition(), equiv_oracle::limit_check(), linearize_expr_tree(), live_edge_for_reg(), live_on_entry(), live_on_exit(), live_worklist(), local_cprop_pass(), local_variable_can_escape(), lookup_stmt_eh_lp(), loop_compare_func(), loop_invariant_motion_in_fun(), loop_optimizer_finalize(), loop_optimizer_init(), loop_preheader_edge(), loops_state_clear(), loops_state_satisfies_p(), loops_state_set(), lower_assumption(), lower_builtin_setjmp(), lower_eh_constructs_2(), lower_eh_dispatch(), lower_emutls_function_body(), lower_function_body(), lower_gimple_return(), lower_omp_ordered(), lower_rec_input_clauses(), lower_resx(), lower_stmt(), lra(), lra_coalesce(), lra_create_live_ranges_1(), lra_final_code_change(), lra_inheritance(), lra_process_new_insns(), lra_remat(), lto_input_tree_1(), main_block_label(), make_blocks(), make_cond_expr_edges(), make_edges(), make_edges(), make_edges_bb(), make_eh_dispatch_edges(), make_eh_edge(), make_gimple_asm_edges(), make_gimple_switch_edges(), make_goto_expr_edges(), make_more_copies(), make_split_prologue_seq(), make_ssa_name(), make_temp_ssa_name(), cgraph_node::mark_address_taken(), mark_addressable(), mark_aliased_reaching_defs_necessary_1(), mark_all_labels(), mark_all_loops_for_removal(), mark_artificial_uses(), mark_control_dependent_edges_necessary(), mark_dfs_back_edges(), mark_elimination(), mark_irreducible_loops(), mark_loop_exit_edges(), mark_loops_for_removal(), mark_phi_for_rewrite(), mark_reachable_handlers(), mark_ssa_maybe_undefs(), mark_stmt_if_obviously_necessary(), mark_target_live_regs(), fwd_jt_path_registry::mark_threaded_blocks(), mark_transaction_restart_calls(), mark_virtual_operand_for_renaming(), match_simplify_replacement(), may_use_storent_in_loop_p(), maybe_add_sra_candidate(), maybe_clean_eh_stmt(), maybe_clean_or_replace_eh_stmt(), maybe_diag_stxncpy_trunc(), maybe_duplicate_eh_stmt(), maybe_hot_edge_p(), maybe_move_debug_stmts_to_successors(), maybe_optimize_range_tests(), maybe_optimize_var(), maybe_output_constant_def_contents(), maybe_push_res_to_seq(), maybe_register_def(), maybe_remove_unreachable_handlers(), maybe_set_dependence_info(), maybe_warn_operand(), merge_blocks_move(), merge_if_block(), merge_loop_tree(), merge_stmts_p(), minmax_from_comparison(), ipa_param_adjustments::modify_call(), ipa_param_body_adjustments::modify_cfun_body(), more_one_region_p(), move_block_to_fn(), move_loop_invariants(), move_sese_region_to_fn(), move_stmt_op(), movement_possibility_1(), name_registered_for_update_p(), nearest_common_dominator_for_set(), nearest_common_dominator_of_uses(), neuter_worker_single(), new_label_mapper(), new_omp_context(), new_temp_expr_table(), new_tree_live_info(), non_spilled_static_chain_regno_p(), noncall_stmt_may_be_vtbl_ptr_store(), nonnull_arg_p(), notice_special_calls(), num_loop_branches(), oacc_do_neutering(), oacc_entry_exit_ok(), oacc_entry_exit_ok_1(), oacc_entry_exit_single_gang(), oacc_loop_discovery(), oacc_xform_loop(), omp_context_selector_matches(), omp_maybe_offloaded(), omp_resolve_declare_variant(), omp_resolve_late_declare_variant(), omp_sese_discover_pars(), omp_sese_split_blocks(), one_code_hoisting_pass(), one_cprop_pass(), one_pre_gcse_pass(), one_store_motion_pass(), opt_info_start_duplication(), optimize_atomic_bit_test_and(), optimize_atomic_op_fetch_cmp_0(), optimize_bb_for_size_p(), optimize_dyn_tls_for_decl_p(), optimize_edge_for_size_p(), optimize_inline_calls(), optimize_insn_for_size_p(), optimize_mask_stores(), optimize_omp_library_calls(), optimize_range_tests(), optimize_range_tests_to_bit_test(), optimize_range_tests_var_bound(), optimize_stack_restore(), optimize_successive_divisions_p(), optimize_tail_call(), optimize_va_list_gpr_fpr_size(), optimize_vectors_before_lowering_p(), optimize_vectors_before_lowering_p(), outgoing_edges_match(), output_function(), output_one_function_exception_table(), parallelize_loops(), param_change_prob(), parm_object_size(), function_reader::parse_block(), function_reader::parse_mem_expr(), function_reader::parse_param(), pass_init_dump_file(), patch_jump_insn(), peephole2_optimize(), perform_intra_sra(), perform_tree_ssa_dce(), place_prologue_for_one_component(), points_to_local_or_readonly_memory_p(), update_list::pop(), pop_cfun(), populate_coalesce_list_for_outofssa(), back_threader_profitability::possibly_profitable_path_p(), post_order_compute(), pre_and_rev_post_order_compute(), pre_edge_lcm(), pre_edge_lcm_avs(), pre_edge_rev_lcm(), pre_expr_reaches_here_p(), pre_expr_reaches_here_p_work(), rvrp_folder::pre_fold_stmt(), predict_loops(), prepare_block_for_update(), prepare_block_for_update_1(), prepare_cmp_insn(), prepare_def_site_for(), prepare_function_start(), prepare_use_sites_for(), prescan_insns_for_dce(), print_edge_list(), print_loop(), print_loop_info(), print_loop_title(), print_loops(), print_rtl_with_bb(), process_bb_lives(), process_bb_node_lives(), profile_function(), profile_record_account_profile(), profile_record_check_consistency(), back_threader_profitability::profitable_path_p(), propagate_freq(), propagate_necessity(), propagate_unlikely_bbs_forward(), propagate_with_phi(), prune_bbs_to_update_dominators(), prune_expressions(), prune_insertions_deletions(), prune_unused_phi_nodes(), pt_solution_empty_p(), pt_solution_includes_1(), pt_solution_includes_global(), pt_solution_set(), pt_solution_set_var(), purge_all_dead_edges(), purge_dead_edges(), push_cfun(), push_reload(), push_struct_function(), push_to_next_round_p(), ranger_cache::range_from_dom(), dom_ranger::range_in_bb(), ssa_cache::range_of_expr(), ranger_cache::ranger_cache(), reachable_at_most_once(), read_profile_edge_counts(), read_rtl_function_body_from_file_range(), reassociate_bb(), cgraph_edge::rebuild_edges(), rebuild_frequencies(), cgraph_edge::rebuild_references(), rebuild_regno_allocno_maps(), record_dynamic_alloc(), record_edge_info(), record_effective_endpoints(), record_final_call(), record_loop_exits(), record_modified(), record_new_stack_level(), record_nonwrapping_iv(), record_stmt_eh_region(), redirect_eh_dispatch_edge(), reemit_insn_block_notes(), reemit_marker_as_note(), ref_may_alias_global_p_1(), refine_value_range_using_guard(), reg_nonzero_bits_for_combine(), reg_num_sign_bit_copies_for_combine(), reg_save(), register_division_in(), regno_clobbered_at_setjmp(), regrename_analyze(), regstat_bb_compute_calls_crossed(), regstat_compute_calls_crossed(), regstat_compute_ri(), relax_delay_slots(), release_ssa_name(), release_ssa_name_after_update_ssa(), relink_block_chain(), reload(), reload_as_needed(), reload_combine(), reload_cse_regs_1(), remap_decls(), remap_dependence_clique(), remap_gimple_stmt(), remap_ssa_name(), remove_unreachable::remove_and_update_globals(), remove_bb(), remove_dead_stmt(), remove_edge_and_dominated_blocks(), remove_edge_raw(), remove_eh_handler(), remove_eh_handler_splicer(), remove_eh_landing_pad(), remove_fake_edges(), remove_fake_exit_edges(), remove_indirect_clobbers(), remove_inheritance_pseudos(), remove_path(), remove_reachable_equiv_notes(), remove_scratches(), remove_scratches(), remove_stmt_from_eh_lp(), remove_unnecessary_regions(), remove_unreachable_eh_regions(), remove_unreachable_handlers(), remove_unreachable_handlers_no_lp(), remove_unused_locals(), renumber_gimple_stmt_uids_in_blocks(), reorder_basic_blocks(), reorder_basic_blocks_simple(), reorder_basic_blocks_software_trace_cache(), reorder_loops(), replace_func_exit(), replace_loop_annotate(), replace_loop_annotate_in_block(), replace_phi_edge_with_variable(), replace_ref_with(), replace_stmt_with_simplification(), replace_uses_by(), report_predictor_hitrates(), reposition_prologue_and_epilogue_notes(), requires_stack_frame_p(), reset_cluster_vectors(), ipa_param_body_adjustments::reset_debug_stmts(), reset_evolution_in_loop(), reset_unmarked_insns_debug_uses(), rest_of_clean_state(), rest_of_handle_dse(), returning_call_p(), rewrite_blocks(), rewrite_debug_stmt_uses(), rewrite_into_loop_closed_ssa_1(), rewrite_stmt(), rewrite_trees(), rotate_loop(), rtl_account_profile_record(), rtl_block_empty_p(), rtl_can_merge_blocks(), rtl_can_remove_branch_p(), rtl_create_basic_block(), rtl_flow_call_edges_add(), rtl_profile_for_bb(), rtl_split_edge(), rtl_verify_bb_insn_chain(), rtl_verify_bb_insns(), rtl_verify_bb_layout(), rtl_verify_bb_pointers(), rtl_verify_edges(), rtl_verify_fallthru(), run_rpo_vn(), run_rtl_passes(), same_addr_size_stores_p(), same_phi_alternatives(), same_succ_flush_bbs(), same_succ_hash(), sbr_vector::sbr_vector(), scan_function(), scan_insn(), scan_trace(), scev_finalize(), scev_initialize(), scev_reset(), scev_var_range_cant_overflow(), secname_for_decl(), sel_bb_empty_or_nop_p(), select_best_block(), sese_build_liveouts(), set_bb_counts(), set_bb_indices(), block_range_cache::set_bb_range(), set_cfun(), set_cluster(), control_dependences::set_control_dependence_map_bit(), set_edge_can_fallthru_flag(), ranger_cache::set_global_range(), set_livein_block(), set_mem_attributes_minus_bitpos(), set_nonzero_bits_and_sign_copies(), dom_oracle::set_one_relation(), set_parm_default_def_partition(), set_parm_rtl(), set_strlen_range(), set_switch_stmt_execution_predicate(), set_var_live_on_entry(), setup_entered_from_non_parent_p(), setup_incoming_promotions(), setup_one_parameter(), should_hoist_expr_to_dom(), should_skip_pass_p(), simd_clone_adjust(), simd_clone_linear_addend(), simple_dce_from_worklist(), simple_mem(), simplify_context::simplify_binary_operation_1(), simplify_conversion_using_ranges(), simplify_gimple_switch_label_vec(), simplify_rotate(), simplify_using_ranges::simplify_switch_using_ranges(), simplify_using_initial_conditions(), simplify_using_initial_values(), ssa_propagation_engine::simulate_block(), single_likely_exit(), single_pred_before_succ_order(), sink_code_in_bb(), sink_common_stores_to_bb(), size_must_be_zero_p(), sjlj_assign_call_site_values(), sjlj_build_landing_pads(), sjlj_emit_dispatch_table(), sjlj_emit_function_enter(), sjlj_fix_up_crossing_landing_pad(), skip_insns_after_block(), skip_pass(), slsr_process_phi(), sort_sibling_loops(), spaceship_replacement(), spill_pseudos(), split_all_insns(), split_bb_make_tm_edge(), split_constant_offset(), split_critical_edges(), split_function(), split_live_ranges_for_shrink_wrap(), split_paths(), spread_components(), sra_get_max_scalarization_size(), sra_initialize(), sra_modify_function_body(), ssa_is_replaceable_p(), ssa_name_has_boolean_range(), ssa_prop_init(), ssa_propagation_engine::ssa_propagate(), stabilize_va_list_loc(), stack_protect_return_slot_p(), statement_sink_location(), statistics_fini_pass_2(), stmt_can_terminate_bb_p(), stmt_kills_ref_p(), stmt_uses_0_or_null_in_undefined_way(), stmt_uses_name_in_undefined_way(), stream_in_histogram_value(), stream_read_tree_ref(), stringop_block_profile(), substitute_and_fold_engine::substitute_and_fold(), suitable_cond_bb(), suitable_for_tail_call_opt_p(), suitable_for_tail_opt_p(), gimple_outgoing_range::switch_edge_range(), tail_duplicate(), tail_merge_optimize(), jump_threader::thread_around_empty_blocks(), thread_prologue_and_epilogue_insns(), jt_path_registry::thread_through_all_blocks(), jump_threader::thread_through_normal_block(), tidy_fallthru_edges(), tm_memopt_compute_antic(), tm_memopt_compute_available(), tm_region_init(), transform_statements(), tree_bb_level_predictions(), tree_builtin_call_types_compatible_p(), tree_could_throw_p(), tree_dce_init(), tree_estimate_probability(), tree_estimate_probability_bb(), tree_forwarder_block_p(), tree_function_versioning(), tree_if_conversion(), tree_loop_unroll_and_jam(), tree_lower_complex(), tree_optimize_tail_calls_1(), tree_predictive_commoning(), tree_profiling(), tree_ssa_iv_optimize(), tree_ssa_lim_finalize(), tree_ssa_lim_initialize(), tree_ssa_loop_done(), tree_ssa_prefetch_arrays(), tree_ssa_split_loops(), tree_unroll_loops_completely(), tree_unroll_loops_completely_1(), try_combine(), try_crossjump_bb(), try_crossjump_to_edge(), try_forward_edges(), try_head_merge_bb(), try_optimize_cfg(), try_redirect_by_replacing_jump(), try_shrink_wrapping(), try_simplify_condjump(), tree_switch_conversion::switch_decision_tree::try_switch_expansion(), unchecked_make_edge(), unlikely_executed_bb_p(), unloop_loops(), unroll_jam_possible_p(), unroll_loops(), unshare_all_rtl(), unshare_all_rtl_again(), unsplit_all_eh(), unsplit_eh(), update_alias_info_with_stack_vars(), update_bb_reg_pressure(), fwd_jt_path_registry::update_cfg(), update_crossing_jump_flags(), update_debug_stmts(), update_dominators_in_loop(), update_equiv_regs(), update_equiv_regs_prescan(), update_inc_notes(), autofdo::autofdo_source_profile::update_inlined_ind_target(), update_list::update_list(), update_loop_exit_probability_scale_dom_bbs(), update_max_bb_count(), update_modified_stmt(), update_modified_stmts(), update_nonlocal_goto_save_area(), update_parameter_components(), update_profile_for_new_sub_basic_block(), update_range_test(), update_ssa(), update_stmt(), update_stmt_if_modified(), update_worklist(), use_register_for_decl(), use_shrink_wrapping_separate(), used_types_insert(), va_list_counter_bump(), va_list_counter_op(), va_list_ptr_write(), value_replacement(), variable_tracking_main_1(), vect_build_slp_tree_1(), vect_do_peeling(), vect_find_stmt_data_reference(), vect_finish_stmt_generation_1(), vect_get_range_info(), vect_is_simple_iv_evolution(), vect_recog_divmod_pattern(), vect_slp_node_weight(), vect_transform_loops(), vectorizable_call(), vectorizable_simd_clone_call(), vectorizable_store(), verify_dominators(), verify_edge_list(), verify_eh_dispatch_edge(), verify_eh_edges(), verify_expr_location_1(), verify_flow_info(), verify_gimple_in_cfg(), verify_gimple_label(), verify_gimple_phi(), verify_gimple_return(), verify_histograms(), verify_hot_cold_block_grouping(), verify_live_on_entry(), verify_loop_closed_ssa(), verify_loop_structure(), verify_no_unreachable_blocks(), verify_non_ssa_vars(), verify_ssa(), verify_ssa_name(), verify_types_in_gimple_reference(), rt_bb_visited::vindex(), rt_bb_visited::visit(), vn_nary_op_get_predicated_value(), vn_nary_op_insert_into(), vn_reference_insert(), vn_reference_lookup(), vn_reference_lookup_2(), vt_add_function_parameter(), vt_emit_notes(), vt_finalize(), vt_find_locations(), vt_initialize(), vt_stack_adjustments(), dom_walker::walk(), walk_to_nondebug_insn(), want_to_gcse_p(), warn_return_addr_local(), warn_uninit_phi_uses(), and warn_uninitialized_vars().

◆ current_function_allocates_dynamic_stack_space

#define current_function_allocates_dynamic_stack_space
Value:
#define current_function_has_unbounded_dynamic_stack_size
Definition function.h:240
#define current_function_dynamic_stack_size
Definition function.h:238

Referenced by output_stack_usage_1().

◆ current_function_dynamic_stack_size

#define current_function_dynamic_stack_size   (cfun->su->dynamic_stack_size)

◆ current_function_funcdef_no

◆ current_function_has_unbounded_dynamic_stack_size

#define current_function_has_unbounded_dynamic_stack_size    (cfun->su->has_unbounded_dynamic_stack_size)

◆ current_function_pushed_stack_size

#define current_function_pushed_stack_size   (cfun->su->pushed_stack_size)

◆ current_function_static_stack_size

#define current_function_static_stack_size   (cfun->su->static_stack_size)

Referenced by output_stack_usage_1().

◆ current_loops

#define current_loops   (cfun->x_current_loops)

Referenced by add_exit_phis(), analyze_memory_references(), bypass_block(), calculate_loop_reg_pressure(), cfg_layout_can_merge_blocks_p(), cfg_layout_duplicate_bb(), change_loop(), rt_bb_visited::check(), cleanup_cfg(), cleanup_tree_cfg(), cleanup_tree_cfg_noloop(), clear_bb_flags(), copy_cfg_body(), create_cond_insert_point(), create_loop_tree_node_allocnos(), create_loop_tree_nodes(), create_preheaders(), delete_basic_block(), delete_loop(), determine_loop_nest_reuse(), do_reload(), do_store_motion(), dump_recorded_exits(), duplicate_block(), dw2_build_landing_pads(), estimate_loops(), execute_fixup_cfg(), execute_function_todo(), expand_omp_sections(), fill_always_executed_in(), fill_coldest_and_hotter_out_loop(), find_if_case_2(), fix_bb_placement(), fix_bb_placements(), fix_loop_placement(), fix_loop_structure(), flow_loops_dump(), force_nonfallthru(), form_loop_tree(), forwarder_block_p(), get_exit_descriptions(), get_loop_exit_edges_unique_dests(), gimple_can_merge_blocks_p(), gimple_merge_blocks(), gsi_insert_finally_seq_after_call(), insert_check_and_trap(), insert_cond_bb(), rt_bb_visited::insert_exit_check_on_edge(), ira(), ira_build(), ira_loop_edge_freq(), loop_invariant_motion_in_fun(), loop_optimizer_init(), loops_state_clear(), make_forwarder_block(), mark_all_loops_for_removal(), mark_irreducible_loops(), mark_loops_for_removal(), mark_ref_loaded(), mark_ref_regs(), mark_ref_stored(), mark_regno_live(), merge_blocks(), merge_blocks_move(), more_one_region_p(), move_block_to_fn(), move_sese_region_to_fn(), outermost_invariant_loop_for_expr(), print_loop_title(), rebuild_regno_allocno_maps(), record_loop_exits(), redirect_edge_and_branch(), redirect_edge_and_branch_force(), remove_bb(), remove_edge(), remove_edge_and_dominated_blocks(), remove_forwarder_block(), remove_forwarder_block_with_phi(), remove_unnecessary_regions(), replace_uses_by(), rescan_loop_exit(), rtl_can_merge_blocks(), setup_entered_from_non_parent_p(), sjlj_emit_dispatch_table(), split_block_1(), split_edge(), split_function(), tree_forwarder_block_p(), tree_unroll_loops_completely(), unloop_loops(), verify_flow_info(), and verify_loop_structure().

◆ dom_computed

◆ FOR_EACH_LOCAL_DECL

◆ forced_labels

◆ inhibit_defer_pop

#define inhibit_defer_pop   (crtl->expr.x_inhibit_defer_pop)

◆ MINIMUM_METHOD_BOUNDARY

#define MINIMUM_METHOD_BOUNDARY
Value:
#define TARGET_PTRMEMFUNC_VBIT_LOCATION
Definition defaults.h:899
#define MAX(X, Y)
Definition system.h:393
@ ptrmemfunc_vbit_in_pfn
Definition tree-core.h:894
If pointers to member functions use the least significant bit to
indicate whether a function is virtual, ensure a pointer
to this function will have that bit clear.   

◆ n_bbs_in_dom_tree

#define n_bbs_in_dom_tree   (cfun->cfg->x_n_bbs_in_dom_tree)

◆ pending_stack_adjust

◆ reg_rtx_no

#define reg_rtx_no   (crtl->emit.x_reg_rtx_no)
For backward compatibility... eventually these should all go away.   

Referenced by ensure_regno(), emit_status::ensure_regno_capacity(), gen_reg_rtx(), init_emit(), and max_reg_num().

◆ REGNO_POINTER_ALIGN

#define REGNO_POINTER_ALIGN ( REGNO)    (crtl->emit.regno_pointer_align[REGNO])

◆ saveregs_value

#define saveregs_value   (crtl->expr.x_saveregs_value)

Referenced by expand_builtin_saveregs().

◆ stack_pointer_delta

◆ SUB_PARM_SIZE

#define SUB_PARM_SIZE ( TO,
DEC )
Value:
do { \
tree dec = (DEC); \
(TO).constant -= tree_to_shwi (dec); \
else if ((TO).var == 0) \
(TO).var = size_binop (MINUS_EXPR, ssize_int (0), \
else \
(TO).var = size_binop (MINUS_EXPR, (TO).var, \
} while (0)

Referenced by locate_and_pad_parm(), and pad_below().

◆ VA_LIST_MAX_FPR_SIZE

◆ VA_LIST_MAX_GPR_SIZE

#define VA_LIST_MAX_GPR_SIZE   255
If va_list_[gf]pr_size is set to this, it means we don't know how
many units need to be saved.   

Referenced by allocate_struct_function(), check_all_va_list_escapes(), optimize_va_list_gpr_fpr_size(), va_list_counter_bump(), va_list_counter_op(), and va_list_ptr_write().

◆ VALUE_HISTOGRAMS

#define VALUE_HISTOGRAMS ( fun)    (fun)->value_histograms

Typedef Documentation

◆ call_site_record

Enumeration Type Documentation

◆ stack_clash_probes

Enumerator
NO_PROBE_NO_FRAME 
NO_PROBE_SMALL_FRAME 
PROBE_INLINE 
PROBE_LOOP 

Function Documentation

◆ active_insn_between()

bool active_insn_between ( rtx_insn * head,
rtx_insn * tail )
extern

◆ add_local_decl()

◆ aggregate_value_p()

◆ allocate_struct_function()

void allocate_struct_function ( tree fndecl,
bool abstract_p )
extern
Allocate a function structure for FNDECL and set its contents
to the defaults.  Set cfun to the newly-allocated object.
Some of the helper functions invoked during initialization assume
that cfun has already been set.  Therefore, assign the new object
directly into cfun and invoke the back end hook explicitly at the
very end, rather than initializing a temporary and calling set_cfun
on it.

ABSTRACT_P is true if this is a function that will never be seen by
the middle-end.  Such functions are front-end concepts (like C++
function templates) that do not correspond directly to functions
placed in object files.   

References aggregate_value_p(), allocate_stack_usage_info(), cfun, current_function_funcdef_no, DECL_ARGUMENTS, DECL_CHAIN, DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT, DECL_RESULT, DECL_STRUCT_FUNCTION, lang_hooks::emits_begin_stmt, get_next_funcdef_no(), ggc_alloc(), init_eh_for_function(), init_machine_status, invoke_set_current_function_hook(), MAY_HAVE_DEBUG_MARKER_STMTS, NULL_TREE, relayout_decl(), stdarg_p(), targetm, TREE_TYPE, VA_LIST_MAX_FPR_SIZE, and VA_LIST_MAX_GPR_SIZE.

Referenced by cgraph_build_static_cdtor_1(), function_reader::create_function(), create_loop_fn(), cgraph_node::create_wrapper(), expand_thunk(), finalize_size_functions(), init_lowered_empty_function(), push_function_context(), and push_struct_function().

◆ assign_stack_local()

◆ assign_stack_local_1()

rtx assign_stack_local_1 ( machine_mode mode,
poly_int64 size,
int align,
int kind )
extern
Allocate a stack slot of SIZE bytes and return a MEM rtx for it
with machine mode MODE.

ALIGN controls the amount of alignment for the address of the slot:
0 means according to MODE,
-1 means use BIGGEST_ALIGNMENT and round size to multiple of that,
-2 means use BITS_PER_UNIT,
positive specifies alignment boundary in bits.

KIND has ASLK_REDUCE_ALIGN bit set if it is OK to reduce
alignment and ASLK_RECORD_PAD bit set if we should remember
extra space we allocated for alignment purposes.  When we are
called from assign_stack_temp_for_type, it is not set so we don't
track the same stack slot in two independent lists.

We do not round to stack_boundary here.   

References add_frame_space(), ASLK_RECORD_PAD, ASLK_REDUCE_ALIGN, crtl, current_function_decl, FRAME_GROWS_DOWNWARD, frame_offset, frame_offset_overflow(), frame_pointer_rtx, gcc_assert, gcc_checking_assert, gen_rtx_MEM(), GET_MODE_ALIGNMENT, GET_MODE_SIZE(), get_stack_local_alignment(), ggc_alloc(), known_eq, known_gt, known_lt, frame_space::length, MAX_SUPPORTED_STACK_ALIGNMENT, MEM_NOTRAP_P, frame_space::next, NULL, plus_constant(), set_mem_align(), STACK_ALIGNMENT_NEEDED, stack_slot_list, frame_space::start, SUPPORTS_STACK_ALIGNMENT, targetm, trunc_int_for_mode(), try_fit_stack_local(), vec_safe_push(), virtual_stack_vars_rtx, and virtuals_instantiated.

Referenced by assign_stack_local(), assign_stack_temp_for_type(), and setup_save_areas().

◆ assign_stack_temp()

rtx assign_stack_temp ( machine_mode mode,
poly_int64 size )
extern
Allocate a temporary stack slot and record it for possible later
reuse.  First two arguments are same as in preceding function.   

References assign_stack_temp_for_type(), NULL_TREE, and temp_slot::size.

Referenced by emit_group_load_1(), emit_group_store(), emit_library_call_value_1(), expand_assignment(), expand_builtin_issignaling(), expand_expr_real_1(), extract_bit_field_1(), and store_bit_field_1().

◆ assign_stack_temp_for_type()

rtx assign_stack_temp_for_type ( machine_mode mode,
poly_int64 size,
tree type )
extern

◆ assign_temp()

rtx assign_temp ( tree type_or_decl,
int memory_required,
int dont_promote )
extern
Assign a temporary.
If TYPE_OR_DECL is a decl, then we are doing it on behalf of the decl
and so that should be used in error messages.  In either case, we
allocate of the given type.
MEMORY_REQUIRED is 1 if the result must be addressable stack memory;
it is 0 if a register is OK.
DONT_PROMOTE is 1 if we should not promote values in register
to wider modes.   

References assign_stack_temp_for_type(), COMPLETE_TYPE_P, DECL_P, error(), gcc_assert, gen_reg_rtx(), ggc_alloc(), known_eq, max_int_size_in_bytes(), NULL, poly_int_tree_p(), promote_mode(), temp_slot::size, TREE_ADDRESSABLE, TREE_CODE, TREE_TYPE, type(), TYPE_MODE, TYPE_SIZE_UNIT, and TYPE_UNSIGNED.

Referenced by emit_library_call_value_1(), emit_push_insn(), expand_asm_stmt(), expand_builtin_cexpi(), expand_call(), expand_cond_expr_using_cmove(), expand_constructor(), expand_expr_real_1(), expand_expr_real_2(), expand_return(), expand_vector_ubsan_overflow(), get_temp_reg(), initialize_argument_information(), and store_one_arg().

◆ block_chainon()

tree block_chainon ( tree op1,
tree op2 )
extern
Concatenate two chains of blocks (chained through BLOCK_CHAIN)
by modifying the last node in chain 1 to point to chain 2.   

References BLOCK_CHAIN, and gcc_assert.

◆ blocks_nreverse()

tree blocks_nreverse ( tree t)
extern
Reverse the order of elements in the chain T of blocks,
and return the new head of the chain (old last element).   

References BLOCK_CHAIN.

Referenced by lower_function_body(), lower_gimple_bind(), and remap_blocks().

◆ clear_block_marks()

void clear_block_marks ( tree block)
extern
Helper function for reorder_blocks.  Reset TREE_ASM_WRITTEN.   

References BLOCK_CHAIN, BLOCK_SUBBLOCKS, clear_block_marks(), and TREE_ASM_WRITTEN.

Referenced by clear_block_marks(), lower_function_body(), and reorder_blocks().

◆ clobber_return_register()

◆ convert_jumps_to_returns()

vec< edge > convert_jumps_to_returns ( basic_block last_bb,
bool simple_p,
vec< edge > unconverted )
extern

◆ current_function_name()

◆ diddle_return_value()

void diddle_return_value ( void(*)(rtx, void *) doit,
void * arg )
extern
Call DOIT for each hard register used as a return value from
the current function.   

References crtl, diddle_return_value_1(), and ggc_alloc().

Referenced by clobber_return_register(), df_get_exit_block_use_set(), and use_return_register().

◆ dump_stack_clash_frame_info()

void dump_stack_clash_frame_info ( enum stack_clash_probes probes,
bool residuals )
extern
If debugging dumps are requested, dump information about how the
target handled -fstack-check=clash for the prologue.

PROBES describes what if any probes were emitted.

RESIDUALS indicates if the prologue had any residual allocation
(i.e. total allocation was not a multiple of PROBE_INTERVAL).   

References cfun, dump_file, frame_pointer_needed, ggc_alloc(), NO_PROBE_NO_FRAME, NO_PROBE_SMALL_FRAME, PROBE_INLINE, PROBE_LOOP, and TREE_THIS_VOLATILE.

◆ emit_initial_value_sets()

void emit_initial_value_sets ( void )
extern
Called from gimple_expand_cfg.   

References crtl, emit_insn_at_entry(), emit_move_insn(), end_sequence(), get_insns(), ggc_alloc(), i, and start_sequence().

◆ emit_return_for_exit()

basic_block emit_return_for_exit ( edge exit_fallthru_edge,
bool simple_p )
extern

◆ emit_return_into_block()

void emit_return_into_block ( bool simple_p,
basic_block bb )
extern

◆ epilogue_contains()

bool epilogue_contains ( const rtx_insn * insn)
extern

References contains(), and epilogue_insn_hash.

◆ expand_dummy_function_end()

void expand_dummy_function_end ( void )
extern

◆ expand_function_end()

◆ expand_function_start()

◆ fndecl_name()

const char * fndecl_name ( tree fndecl)
extern
Returns the name of the current function.   
Returns the name of function declared by FNDECL.   

References lang_hooks::decl_printable_name, and NULL.

Referenced by cgraph_node::add_new_function(), function_name(), get_static_name(), and ipa_reference_read_optimization_summary().

◆ frame_offset_overflow()

bool frame_offset_overflow ( poly_int64 offset,
tree func )
extern
Issue an error message and return TRUE if frame OFFSET overflows in
the signed target pointer arithmetics for function FUNC.  Otherwise
return FALSE.   

References coeffs_in_range_p(), DECL_SOURCE_LOCATION, error_at(), FRAME_GROWS_DOWNWARD, GET_MODE_BITSIZE(), ggc_alloc(), HOST_WIDE_INT_1U, poly_int< N, C >::is_constant(), and offset.

Referenced by alloc_stack_frame_space(), and assign_stack_local_1().

◆ free_after_compilation()

void free_after_compilation ( struct function * f)
extern
Clear out all parts of the state in F that can safely be discarded
after the function has been compiled, to let garbage collection
reclaim the memory.   

References function::cfg, function::cond_uids, crtl, function::curr_properties, function::eh, epilogue_insn_hash, free(), ggc_alloc(), function::machine, NULL, prologue_insn_hash, and regno_reg_rtx.

Referenced by expand_dummy_function_end(), expand_thunk(), and rest_of_clean_state().

◆ free_after_parsing()

void free_after_parsing ( struct function * f)
extern
Save and restore status information for a nested function.   
Clear out all parts of the state in F that can safely be discarded
after the function has been parsed, but not compiled, to let
garbage collection reclaim the memory.   

References function::language.

Referenced by expand_dummy_function_end(), and rest_of_clean_state().

◆ free_temp_slots()

void free_temp_slots ( void )
extern

◆ function_name()

◆ generate_setjmp_warnings()

void generate_setjmp_warnings ( void )
extern

◆ get_arg_pointer_save_area()

◆ get_frame_size()

poly_int64 get_frame_size ( void )
extern
Return size needed for stack frame based on slots so far allocated.
This size counts from zero.  It is not rounded to STACK_BOUNDARY;
the caller may have to do that.   
Return size needed for stack frame based on slots so far allocated.
This size counts from zero.  It is not rounded to PREFERRED_STACK_BOUNDARY;
the caller may have to do that.   

References FRAME_GROWS_DOWNWARD, and frame_offset.

Referenced by do_reload(), final_start_function_1(), get_initial_register_offset(), lra(), reload(), and rtx_addr_can_trap_p_1().

◆ get_hard_reg_initial_reg()

rtx get_hard_reg_initial_reg ( rtx reg)
extern
If a pseudo represents an initial hard reg (or expression), return
it, else return NULL_RTX.   

References crtl, ggc_alloc(), i, NULL_RTX, and rtx_equal_p().

◆ get_hard_reg_initial_val()

rtx get_hard_reg_initial_val ( machine_mode mode,
unsigned int regno )
extern
Make sure that there's a pseudo register of mode MODE that stores the
initial value of hard register REGNO.  Return an rtx for such a pseudo.   

References crtl, gen_reg_rtx(), gen_rtx_REG(), ggc_alloc(), GGC_RESIZEVEC, and has_hard_reg_initial_val().

◆ get_last_funcdef_no()

int get_last_funcdef_no ( void )
extern
Return value of funcdef.   

References funcdef_no.

◆ get_new_clique()

unsigned short get_new_clique ( function * fn)
inline
Get a new unique dependence clique or zero if none is left.   

References function::last_clique.

Referenced by duplicate_insn_chain(), gimple_duplicate_bb(), and remap_dependence_clique().

◆ get_next_funcdef_no()

int get_next_funcdef_no ( void )
extern
Return value of funcdef and increase it.   

References funcdef_no.

Referenced by allocate_struct_function().

◆ get_stack_dynamic_offset()

poly_int64 get_stack_dynamic_offset ( )
extern
Return the value of STACK_DYNAMIC_OFFSET for the current function.
This is done through a function wrapper so that the macro sees a
predictable set of included files.   

References current_function_decl, and STACK_DYNAMIC_OFFSET.

Referenced by allocate_dynamic_stack_space(), and instantiate_virtual_regs().

◆ gimplify_parameters()

◆ has_hard_reg_initial_val()

rtx has_hard_reg_initial_val ( machine_mode mode,
unsigned int regno )
extern
See if get_hard_reg_initial_val has been used to create a pseudo
for the initial value of hard register REGNO in mode MODE.  Return
the associated pseudo if so, otherwise return NULL.   

References crtl, GET_MODE, ggc_alloc(), i, NULL_RTX, and REGNO.

Referenced by get_hard_reg_initial_val().

◆ init_dummy_function_start()

void init_dummy_function_start ( void )
extern
Initialize the rtl expansion mechanism so that we can do simple things
like generate sequences.  This is used to provide a context during global
initialization of some passes.  You must call expand_dummy_function_end
to exit this context.   

References prepare_function_start(), and push_dummy_function().

Referenced by backend_init_target().

◆ init_function_start()

void init_function_start ( tree subr)
extern
Generate RTL for the start of the function SUBR (a FUNCTION_DECL tree node)
and initialize static variables for generating RTL for the statements
of the function.   

References AGGREGATE_TYPE_P, decide_function_section(), DECL_RESULT, DECL_SOURCE_LOCATION, ggc_alloc(), initialize_rtl(), prepare_function_start(), TREE_TYPE, and warning_at().

Referenced by cgraph_node::expand(), and expand_thunk().

◆ init_temp_slots()

◆ initial_value_entry()

bool initial_value_entry ( int i,
rtx * hreg,
rtx * preg )
extern
Return the hardreg-pseudoreg initial values pair entry I and
TRUE if I is a valid entry, or FALSE if I is not a valid entry.   

References crtl, ggc_alloc(), and i.

Referenced by allocate_initial_values().

◆ instantiate_decl_rtl()

void instantiate_decl_rtl ( rtx x)
extern
Subroutine of instantiate_decls.  Given RTL representing a decl,
do any instantiation required.   

References CONSTANT_P, GET_CODE, ggc_alloc(), instantiate_decl_rtl(), instantiate_virtual_regs_in_rtx(), MEM_P, REG_P, VIRTUAL_REGISTER_P, and XEXP.

Referenced by instantiate_decl_rtl(), instantiate_decls(), instantiate_decls_1(), and instantiate_expr().

◆ locate_and_pad_parm()

void locate_and_pad_parm ( machine_mode passed_mode,
tree type,
int in_regs,
int reg_parm_stack_space,
int partial,
tree fndecl,
struct args_size * initial_offset_ptr,
struct locate_and_pad_arg_data * locate )
extern
Compute the size and offset from the start of the stacked arguments for a
parm passed in mode PASSED_MODE and with type TYPE.

INITIAL_OFFSET_PTR points to the current offset into the stacked
arguments.

The starting offset and size for this parm are returned in
LOCATE->OFFSET and LOCATE->SIZE, respectively.  When IN_REGS is
nonzero, the offset is that of stack slot, which is returned in
LOCATE->SLOT_OFFSET.  LOCATE->ALIGNMENT_PAD is the amount of
padding required from the initial offset ptr to the stack slot.

IN_REGS is nonzero if the argument will be passed in registers.  It will
never be set if REG_PARM_STACK_SPACE is not defined.

REG_PARM_STACK_SPACE is the number of bytes of stack space reserved
for arguments which are passed in registers.

FNDECL is the function in which the argument was defined.

There are two types of rounding that are done.  The first, controlled by
TARGET_FUNCTION_ARG_BOUNDARY, forces the offset from the start of the
argument list to be aligned to the specific boundary (in bits).  This
rounding affects the initial and starting offsets, but not the argument
size.

The second, controlled by TARGET_FUNCTION_ARG_PADDING and PARM_BOUNDARY,
optionally rounds the size of the parm to PARM_BOUNDARY.  The
initial offset is not affected by this rounding, while the size always
is and the starting offset may be.   
LOCATE->OFFSET will be negative for ARGS_GROW_DOWNWARD case;
INITIAL_OFFSET_PTR is positive because locate_and_pad_parm's
callers pass in the total size of args so far as
INITIAL_OFFSET_PTR.  LOCATE->SIZE is always positive.   

References ADD_PARM_SIZE, locate_and_pad_arg_data::alignment_pad, arg_size_in_bytes(), ARGS_GROW_DOWNWARD, ARGS_SIZE_TREE, locate_and_pad_arg_data::boundary, args_size::constant, crtl, gcc_assert, GET_MODE_SIZE(), ggc_alloc(), MAX_SUPPORTED_STACK_ALIGNMENT, locate_and_pad_arg_data::offset, pad_below(), PAD_DOWNWARD, PAD_NONE, pad_to_arg_alignment(), round_up, locate_and_pad_arg_data::size, size_binop, size_int, locate_and_pad_arg_data::slot_offset, ssize_int, SUB_PARM_SIZE, SUPPORTS_STACK_ALIGNMENT, targetm, tree_fits_uhwi_p(), TREE_INT_CST_LOW, tree_to_uhwi(), args_size::var, and locate_and_pad_arg_data::where_pad.

Referenced by assign_parm_find_entry_rtl(), emit_library_call_value_1(), and initialize_argument_information().

◆ loops_for_fn()

◆ maybe_copy_prologue_epilogue_insn()

void maybe_copy_prologue_epilogue_insn ( rtx insn,
rtx copy )
extern
INSN has been duplicated or replaced by as COPY, perhaps by duplicating a
basic block, splitting or peepholes.  If INSN is a prologue or epilogue
insn, then record COPY as well.   

References epilogue_insn_hash, hash_table< Descriptor, Lazy, Allocator >::find(), hash_table< Descriptor, Lazy, Allocator >::find_slot(), gcc_assert, ggc_alloc(), NULL, and prologue_insn_hash.

Referenced by copy_frame_info_to_split_insn(), and duplicate_insn_chain().

◆ number_blocks()

void number_blocks ( tree fn)
extern

◆ pop_cfun()

◆ pop_dummy_function()

void pop_dummy_function ( void )
extern

◆ pop_function_context()

void pop_function_context ( void )
extern
Restore the last saved context, at the end of a nested function.
This function is called from language-specific code.   

References current_function_decl, function::decl, function_context_stack, generating_concat_p, set_cfun(), and virtuals_instantiated.

◆ pop_temp_slots()

void pop_temp_slots ( void )
extern

◆ preserve_temp_slots()

void preserve_temp_slots ( rtx x)
extern
If X could be a reference to a temporary slot, mark that slot as
belonging to the to one level higher than the current level.  If X
matched one of our slots, just mark that one.  Otherwise, we can't
easily predict which it is, so upgrade all of them.

This is called when an ({...}) construct occurs and a statement
returns a value in memory.   

References CONSTANT_P, find_temp_slot_from_address(), temp_slot::level, MEM_P, move_slot_to_level(), temp_slot::next, REG_P, REG_POINTER, temp_slot_level, temp_slots_at_level(), and XEXP.

Referenced by expand_assignment(), precompute_register_parameters(), and store_one_arg().

◆ prologue_contains()

bool prologue_contains ( const rtx_insn * insn)
extern

References contains(), and prologue_insn_hash.

◆ prologue_epilogue_contains()

bool prologue_epilogue_contains ( const rtx_insn * insn)
extern

◆ push_cfun()

◆ push_dummy_function()

◆ push_function_context()

void push_function_context ( void )
extern
Save the current context for compilation of a nested function.
This is called from language-specific code.   

References allocate_struct_function(), cfun, function_context_stack, NULL, and set_cfun().

◆ push_struct_function()

void push_struct_function ( tree fndecl,
bool abstract_p )
extern
This is like allocate_struct_function, but pushes a new cfun for FNDECL
instead of just setting it.   

References allocate_struct_function(), cfun, cfun_stack, current_function_decl, gcc_assert, ggc_alloc(), and in_dummy_function.

Referenced by create_assumption_fn(), create_omp_child_function(), gimplify_function_tree(), initialize_cfun(), input_function(), and push_dummy_function().

◆ push_temp_slots()

◆ record_dynamic_alloc()

void record_dynamic_alloc ( tree decl_or_exp)
Record a dynamic allocation made for DECL_OR_EXP.   

References cfun, DECL_P, lang_hooks::decl_printable_name, DECL_SOURCE_LOCATION, EXPR_LOCATION, ggc_alloc(), ggc_strdup, NULL, and vec_safe_push().

Referenced by expand_builtin_alloca(), and gimplify_vla_decl().

◆ record_epilogue_seq()

◆ record_final_call()

void record_final_call ( tree callee,
location_t location )
Record a final call to CALLEE at LOCATION.   

References cfun, ggc_alloc(), and vec_safe_push().

Referenced by emit_library_call_value_1(), and expand_call().

◆ record_prologue_seq()

◆ reorder_blocks()

void reorder_blocks ( void )
extern
Identify BLOCKs referenced by more than one NOTE_INSN_BLOCK_{BEG,END},
and create duplicate blocks.   
Identify BLOCKs referenced by more than one NOTE_INSN_BLOCK_{BEG,END},
and create duplicate blocks.   
??? Need an option to either create block fragments or to create
abstract origin duplicates of a source block.  It really depends
on what optimization has been performed.   

References BLOCK_CHAIN, BLOCK_SUBBLOCKS, blocks_nreverse_all(), clear_block_marks(), current_function_decl, DECL_INITIAL, get_insns(), ggc_alloc(), NULL_TREE, and reorder_blocks_1().

Referenced by reemit_insn_block_notes().

◆ reposition_prologue_and_epilogue_notes()

void reposition_prologue_and_epilogue_notes ( void )
extern
Reposition the prologue-end and epilogue-begin notes after
instruction scheduling.   

References BB_END, cfun, contains(), epilogue_insn_hash, EXIT_BLOCK_PTR_FOR_FN, FOR_BB_INSNS, FOR_EACH_EDGE, get_insns(), ggc_alloc(), LABEL_P, last, NEXT_INSN(), NOTE_KIND, NOTE_P, NULL, PREV_INSN(), prologue_insn_hash, reorder_insns(), and targetm.

◆ set_cfun()

◆ set_loops_for_fn()

void set_loops_for_fn ( struct function * fn,
struct loops * loops )
inline

◆ set_return_jump_label()

void set_return_jump_label ( rtx_insn * returnjump)
extern
Set JUMP_LABEL for a return insn.   

References ANY_RETURN_P, GET_CODE, ggc_alloc(), JUMP_LABEL, PATTERN(), ret_rtx, and XVECEXP.

Referenced by find_end_label(), force_nonfallthru_and_redirect(), and make_epilogue_seq().

◆ spill_slot_alignment()

unsigned int spill_slot_alignment ( machine_mode mode)
extern
Return the minimum spill slot alignment for a register of mode MODE.   

References GET_MODE_ALIGNMENT, NULL_TREE, and STACK_SLOT_ALIGNMENT.

Referenced by add_pseudo_to_slot().

◆ stack_protect_epilogue()

void stack_protect_epilogue ( void )
extern
Expand code to verify the stack_protect_guard.  This is invoked at
the end of a function to be protected.   

References const0_rtx, crtl, DECL_P, DECL_RTL, emit_cmp_and_jump_insns(), emit_insn(), emit_label(), expand_call(), expand_normal(), free_temp_slots(), gcc_assert, gen_label_rtx(), get_last_insn(), ggc_alloc(), JUMP_P, NULL, NULL_RTX, predict_insn_def(), ptr_mode, TAKEN, targetm, and y.

Referenced by expand_call(), and expand_function_end().

◆ thread_prologue_and_epilogue_insns()

void thread_prologue_and_epilogue_insns ( void )
extern
Generate the prologue and epilogue RTL if the machine supports it.  Thread
this into place with notes indicating where the prologue ends and where
the epilogue begins.  Update the basic block information when possible.

Notes on epilogue placement:
There are several kinds of edges to the exit block:
* a single fallthru edge from LAST_BB
* possibly, edges from blocks containing sibcalls
* possibly, fake edges from infinite loops

The epilogue is always emitted on the fallthru edge from the last basic
block in the function, LAST_BB, into the exit block.

If LAST_BB is empty except for a label, it is the target of every
other basic block in the function that ends in a return.  If a
target has a return or simple_return pattern (possibly with
conditional variants), these basic blocks can be changed so that a
return insn is emitted into them, and their target is adjusted to
the real exit block.

Notes on shrink wrapping: We implement a fairly conservative
version of shrink-wrapping rather than the textbook one.  We only
generate a single prologue and a single epilogue.  This is
sufficient to catch a number of interesting cases involving early
exits.

First, we identify the blocks that require the prologue to occur before
them.  These are the ones that modify a call-saved register, or reference
any of the stack or frame pointer registers.  To simplify things, we then
mark everything reachable from these blocks as also requiring a prologue.
This takes care of loops automatically, and avoids the need to examine
whether MEMs reference the frame, since it is sufficient to check for
occurrences of the stack or frame pointer.

We then compute the set of blocks for which the need for a prologue
is anticipatable (borrowing terminology from the shrink-wrapping
description in Muchnick's book).  These are the blocks which either
require a prologue themselves, or those that have only successors
where the prologue is anticipatable.  The prologue needs to be
inserted on all edges from BB1->BB2 where BB2 is in ANTIC and BB1
is not.  For the moment, we ensure that only one such edge exists.

The epilogue is placed as described above, but we make a
distinction between inserting return and simple_return patterns
when modifying other blocks that end in a return.  Blocks that end
in a sibcall omit the sibcall_epilogue if the block is not in
ANTIC.   

References BB_END, bitmap_clear(), bitmap_set_bit, BLOCK_FOR_INSN(), CALL_P, cfg_layout_finalize(), cfg_layout_initialize(), cfun, commit_edge_insertions(), crtl, default_rtl_profile(), df_analyze(), df_update_entry_block_defs(), df_update_entry_exit_and_calls(), df_update_exit_block_uses(), eh_returnjump_p(), ei_next(), ei_safe_edge(), ei_start, emit_insn(), emit_insn_before(), emit_note(), emit_note_after(), end_sequence(), ENTRY_BLOCK_PTR_FOR_FN, epilogue_completed, epilogue_insn_hash, epilogue_location, EXIT_BLOCK_PTR_FOR_FN, find_fallthru_edge(), find_many_sub_basic_blocks(), find_sub_basic_blocks(), FOR_EACH_BB_FN, FOR_EACH_EDGE, gcc_assert, get_insns(), ggc_alloc(), insert_insn_on_edge(), last, last_basic_block_for_fn, make_epilogue_seq(), make_prologue_seq(), make_split_prologue_seq(), next_active_insn(), NEXT_INSN(), NONDEBUG_INSN_P, NOTE_KIND, NOTE_P, NULL, NUM_FIXED_BLOCKS, PATTERN(), PREV_INSN(), record_insns(), reorder_insns(), returnjump_p(), rtl_profile_for_bb(), set_insn_locations(), SIBLING_CALL_P, single_succ_edge(), single_succ_p(), start_sequence(), targetm, try_shrink_wrapping(), try_shrink_wrapping_separate(), and try_split().

Referenced by rest_of_handle_thread_prologue_and_epilogue().

◆ types_used_by_var_decl_insert()

void types_used_by_var_decl_insert ( tree type,
tree var_decl )

◆ update_temp_slot_address()

void update_temp_slot_address ( rtx old_rtx,
rtx new_rtx )
extern
Indicate that NEW_RTX is an alternate way of referring to the temp
slot that previously was known by OLD_RTX.   

References find_temp_slot_from_address(), GET_CODE, ggc_alloc(), insert_temp_slot_address(), REG_P, rtx_equal_p(), update_temp_slot_address(), and XEXP.

Referenced by memory_address_addr_space(), offset_address(), replace_equiv_address(), and update_temp_slot_address().

◆ use_register_for_decl()

◆ used_types_insert()

void used_types_insert ( tree t)
extern

Variable Documentation

◆ cfun

struct function* cfun
extern
The function currently being compiled.   
The currently compiled function.   

Referenced by push_function_context().

◆ currently_expanding_function_start

bool currently_expanding_function_start
extern
Start the RTL for a new function, and set variables used for
emitting RTL.
SUBR is the FUNCTION_DECL node.
PARMS_HAVE_CLEANUPS is nonzero if there are cleanups associated with
the function's parameters, which must be run at any return statement.   

Referenced by expand_function_start().

◆ init_machine_status

struct machine_function *(* init_machine_status) (void) ( void )
extern
A pointer to a function to create target specific, per-function
data structures.   
These variables hold pointers to functions to create and destroy
target specific, per-function data structures.   

Referenced by allocate_struct_function().

◆ regno_reg_rtx

rtx* regno_reg_rtx
extern
Indexed by register number, gives an rtx for that register (and only
that register).  For pseudo registers, it is the unique rtx for
that pseudo.  For hard registers, it is an rtx of the mode specified
by reg_raw_mode.

FIXME: We could put it into emit_status struct, but gengtype is not
able to deal with length attribute nested in top level structures.   
Indexed by pseudo register number, gives the rtx for that pseudo.
Allocated in parallel with regno_pointer_align.
FIXME: We could put it into emit_status struct, but gengtype is not able to deal
with length attribute nested in top level structures.   

Referenced by allocno_reload_assign(), allocnos_conflict_by_live_ranges_p(), alter_reg(), assign_by_spills(), assign_mem_slot(), assign_parm_setup_reg(), calculate_equiv_gains(), canon_reg(), combine_and_move_insns(), consolidate_reg(), cse_insn(), dead_debug_insert_temp(), decompose_multiword_subregs(), decompose_register(), df_bb_refs_collect(), df_entry_block_defs_collect(), df_exit_block_uses_collect(), df_get_call_refs(), df_insn_refs_collect(), df_ref_change_reg_with_loc_1(), df_ref_record(), df_set_dead_notes_for_mw(), df_set_unused_notes_for_mw(), distribute_notes(), do_input_reload(), dump_reg_info(), emit_reload_insns(), emit_status::ensure_regno_capacity(), equiv_can_be_consumed_p(), expand_asm_reg_clobber_mem_blockage(), find_costs_and_classes(), find_split_point(), free_after_compilation(), gen_reg_rtx(), gen_rtx_REG(), get_subreg_tracking_sizes(), inherit_in_ebb(), inherit_reload_reg(), init_alias_analysis(), init_emit(), init_virtual_regs(), ira_build_conflicts(), ira_emit(), lra_constraints(), lra_create_live_ranges_1(), lra_final_code_change(), move_deaths(), non_spilled_static_chain_regno_p(), process_alt_operands(), process_bb_lives(), record_operand_costs(), reload(), remove_inheritance_pseudos(), remove_init_insns(), replace_pseudos_in(), save_call_clobbered_regs(), setup_preferred_alternate_classes_for_new_pseudos(), setup_regno_cost_classes_by_aclass(), setup_save_areas(), simplify_operand_subreg(), simplify_set(), split_reg(), subst_mode(), substitute(), target_reinit(), try_combine(), undo_to_marker(), use_regs(), and zcur_select_mode_rtx().

◆ trampolines_created

int trampolines_created
extern
Nonzero if at least one trampoline has been created.   
This is a generic routine suitable for use as TARGET_ASM_FILE_END
which emits a special section directive used to indicate whether or
not this object file needs an executable stack.  This is primarily
a GNU extension to ELF but could be used on other targets.   

Referenced by expand_builtin_init_trampoline(), and file_end_indicate_exec_stack().

◆ types_used_by_cur_var_decl

vec<tree, va_gc>* types_used_by_cur_var_decl
extern
During parsing of a global variable, this vector contains the types
referenced by the global variable.   

Referenced by used_types_insert().

◆ types_used_by_vars_hash

hash_table<used_type_hasher>* types_used_by_vars_hash
extern
Hash table making the relationship between a global variable
and the types it references in its initializer. The key of the
entry is a referenced type, and the value is the DECL of the global
variable. types_use_by_vars_do_hash and types_used_by_vars_eq below are
the hash and equality functions to use for this hash table.   

Referenced by types_used_by_var_decl_insert().

◆ virtuals_instantiated

int virtuals_instantiated
extern
Nonzero if we've already converted virtual regs to hard regs.   
Nonzero once virtual register instantiation has been done.
assign_stack_local uses frame_pointer_rtx when this is nonzero.
calls.cc:emit_library_call_value_1 uses it to set up
post-instantiation libcalls.   

Referenced by allocate_dynamic_stack_space(), assign_stack_local_1(), assign_stack_temp_for_type(), emit_library_call_value_1(), instantiate_virtual_regs(), pop_function_context(), and prepare_function_start().