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)

#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)

#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)

#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_d *	call_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 loops *	loops_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< edge >	convert_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 char *	fndecl_name (tree)

const char *	function_name (const function *)

const char *	current_function_name (void)

void	used_types_insert (tree)

Variables
rtx *	regno_reg_rtx

struct function *	cfun

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);                                             \
  if (tree_fits_shwi_p (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,                 \
                           fold_convert (ssizetype, inc));      \
} while (0)

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)

Referenced by expand_builtin_apply_args().

◆ ARGS_SIZE_RTX

#define ARGS_SIZE_RTX ( SIZE )

Value:

((SIZE).var == 0 ? gen_int_mode ((SIZE).constant, Pmode) \

: expand_normal (ARGS_SIZE_TREE (SIZE)))

gen_int_mode

rtx gen_int_mode(poly_int64 c, machine_mode mode)

Definition emit-rtl.cc:544

expand_normal

rtx expand_normal(tree exp)

Definition expr.h:327

ARGS_SIZE_TREE

#define ARGS_SIZE_TREE(SIZE)

Definition function.h:613

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)                  \
 : size_binop (PLUS_EXPR, fold_convert (ssizetype, (SIZE).var), \
               ssize_int ((SIZE).constant)))

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

Referenced by assign_stack_local(), and assign_stack_local_1().

◆ ASLK_REDUCE_ALIGN

#define ASLK_REDUCE_ALIGN 1

Referenced by assign_stack_local_1(), and setup_save_areas().

◆ 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.

◆ current_function_allocates_dynamic_stack_space

#define current_function_allocates_dynamic_stack_space

Value:

(current_function_dynamic_stack_size != 0 \

|| current_function_has_unbounded_dynamic_stack_size)

current_function_has_unbounded_dynamic_stack_size

#define current_function_has_unbounded_dynamic_stack_size

Definition function.h:240

current_function_dynamic_stack_size

#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)

Referenced by allocate_dynamic_stack_space(), and output_stack_usage_1().

◆ current_function_funcdef_no

#define current_function_funcdef_no (cfun->funcdef_no)

For backward compatibility... eventually these should all go away.

Referenced by allocate_struct_function(), asan_emit_stack_protection(), asan_function_start(), rt_bb_visited::check(), coverage_begin_function(), coverage_end_function(), default_elf_asm_named_section(), default_print_patchable_function_entry(), dw_loc_list(), dwarf2out_alloc_current_fde(), dwarf2out_begin_prologue(), dwarf2out_do_cfi_startproc(), dwarf2out_end_epilogue(), dwarf2out_switch_text_section(), dwarf2out_vms_begin_epilogue(), dwarf2out_vms_end_prologue(), expand_function_start(), get_coverage_counts(), output_one_function_exception_table(), profile_function(), and sjlj_emit_function_enter().

◆ current_function_has_unbounded_dynamic_stack_size

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

Referenced by allocate_dynamic_stack_space(), expand_call(), and output_stack_usage_1().

◆ current_function_pushed_stack_size

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

Referenced by emit_library_call_value_1(), expand_call(), and output_stack_usage_1().

◆ 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

#define dom_computed (cfun->cfg->x_dom_computed)

Referenced by add_to_dominance_info(), bb_dom_dfs_in(), bb_dom_dfs_out(), calculate_dominance_info(), calculate_dominance_info_for_region(), compute_dom_fast_query(), compute_dom_fast_query_in_region(), delete_from_dominance_info(), dominated_by_p(), get_dominated_by(), get_immediate_dominator(), iterate_fix_dominators(), nearest_common_dominator(), recompute_dominator(), redirect_immediate_dominators(), set_dom_info_availability(), and set_immediate_dominator().

◆ FOR_EACH_LOCAL_DECL

#define FOR_EACH_LOCAL_DECL	(	FUN,
		I,
		D )

Value:

FOR_EACH_VEC_SAFE_ELT_REVERSE ((FUN)->local_decls, I, D)

I

#define I

Definition gensupport.cc:204

FOR_EACH_VEC_SAFE_ELT_REVERSE

#define FOR_EACH_VEC_SAFE_ELT_REVERSE(V, I, P)

Definition vec.h:1900

Referenced by add_local_variables(), dump_alias_info(), dump_function_to_file(), estimated_stack_frame_size(), expand_used_vars(), find_local_vars_to_propagate(), find_tail_calls(), find_var_candidates(), instantiate_decls(), remove_exit_barrier(), reset_debug_bindings(), and strub_from_body_p().

◆ forced_labels

#define forced_labels (crtl->expr.x_forced_labels)

Referenced by can_delete_label_p(), create_trace_edges(), expand_label(), force_label_rtx(), make_edges(), rebuild_jump_labels_1(), set_initial_label_offsets(), and sjlj_emit_dispatch_table().

◆ inhibit_defer_pop

#define inhibit_defer_pop (crtl->expr.x_inhibit_defer_pop)

Referenced by do_pending_stack_adjust(), emit_call_1(), emit_library_call_value_1(), expand_call(), and restore_pending_stack_adjust().

◆ MINIMUM_METHOD_BOUNDARY

#define MINIMUM_METHOD_BOUNDARY

Value:

((TARGET_PTRMEMFUNC_VBIT_LOCATION == ptrmemfunc_vbit_in_pfn) \

? MAX (FUNCTION_BOUNDARY, 2 * BITS_PER_UNIT) : FUNCTION_BOUNDARY)

TARGET_PTRMEMFUNC_VBIT_LOCATION

#define TARGET_PTRMEMFUNC_VBIT_LOCATION

Definition defaults.h:887

MAX

#define MAX(X, Y)

Definition system.h:393

ptrmemfunc_vbit_in_pfn

@ ptrmemfunc_vbit_in_pfn

Definition tree-core.h:903

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)

Referenced by add_to_dominance_info(), calculate_dominance_info(), and delete_from_dominance_info().

◆ pending_stack_adjust

#define pending_stack_adjust (crtl->expr.x_pending_stack_adjust)

Referenced by combine_pending_stack_adjustment_and_call(), discard_pending_stack_adjust(), do_pending_stack_adjust(), emit_call_1(), emit_library_call_value_1(), expand_call(), init_pending_stack_adjust(), initialize_argument_information(), restore_pending_stack_adjust(), and save_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 )

Value:

(crtl->emit.regno_pointer_align[REGNO])

crtl

#define crtl

Definition emit-rtl.h:347

REGNO

#define REGNO(RTX)

Definition rtl.h:1914

Referenced by get_dynamic_stack_size(), init_emit(), mark_reg_pointer(), nonzero_bits1(), reload(), set_reg_attrs_from_value(), and setup_can_eliminate().

◆ saveregs_value

#define saveregs_value (crtl->expr.x_saveregs_value)

Referenced by expand_builtin_saveregs().

◆ stack_pointer_delta

#define stack_pointer_delta (crtl->expr.x_stack_pointer_delta)

Referenced by adjust_stack(), adjust_stack_1(), allocate_dynamic_stack_space(), anti_adjust_stack(), combine_pending_stack_adjustment_and_call(), compute_argument_block_size(), discard_pending_stack_adjust(), emit_call_1(), emit_library_call_value_1(), expand_builtin_trap(), expand_call(), restore_pending_stack_adjust(), and save_pending_stack_adjust().

◆ SUB_PARM_SIZE

#define SUB_PARM_SIZE	(		TO,
			DEC )

Value:

do {                                                            \
  tree dec = (DEC);                                             \
  if (tree_fits_shwi_p (dec))                                   \
    (TO).constant -= tree_to_shwi (dec);                        \
  else if ((TO).var == 0)                                       \
    (TO).var = size_binop (MINUS_EXPR, ssize_int (0),           \
                           fold_convert (ssizetype, dec));      \
  else                                                          \
    (TO).var = size_binop (MINUS_EXPR, (TO).var,                \
                           fold_convert (ssizetype, dec));      \
} while (0)

Referenced by locate_and_pad_parm(), and pad_below().

◆ VA_LIST_MAX_FPR_SIZE

#define VA_LIST_MAX_FPR_SIZE 255

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

◆ 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 )

Value:

(fun)->value_histograms

Referenced by free_histograms(), gimple_histogram_value(), initialize_cfun(), set_histogram_value(), and verify_histograms().

Typedef Documentation

◆ call_site_record

typedef struct call_site_record_d* call_site_record

Enumeration Type Documentation

◆ stack_clash_probes

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

void add_local_decl	(	struct function *	fun,
		tree	d )

Add the decl D to the local_decls list of FUN.

References gcc_assert, function::local_decls, VAR_P, and vec_safe_push().

Referenced by add_local_variables(), declare_inline_vars(), expand_thunk(), expand_used_vars(), record_vars_into(), remap_decls(), replace_by_duplicate_decl(), and ipa_param_body_adjustments::reset_debug_stmts().

◆ aggregate_value_p()

bool aggregate_value_p	(	const_tree	exp,
		const_tree	fntype )

extern

Return true if EXP is an aggregate type (or a value with aggregate type).
This means a type for which function calls must pass an address to the
function or get an address back from the function.
EXP may be a type node or an expression (whose type is tested).

References AGGREGATE_TYPE_P, aggregate_value_p(), CALL_EXPR_FN, predefined_function_abi::clobbers_full_reg_p(), DECL_BY_REFERENCE, default_function_abi, error_operand_p(), exp(), first_field(), fixed_regs, fntype_abi(), gcc_unreachable, get_callee_fndecl(), hard_function_value(), hard_regno_nregs(), i, NULL_TREE, REG_P, REGNO, targetm, TREE_ADDRESSABLE, TREE_CODE, TREE_TYPE, TYPE_EMPTY_P, TYPE_MODE, TYPE_P, TYPE_TRANSPARENT_AGGR, and VOID_TYPE_P.

Referenced by aggregate_value_p(), allocate_struct_function(), assign_parms_augmented_arg_list(), copy_result_decl_to_var(), emit_library_call_value_1(), expand_assignment(), expand_call(), expand_function_start(), expand_thunk(), find_func_aliases_for_call(), gimple_regimplify_operands(), gimplify_modify_expr_rhs(), gimplify_return_expr(), has_stmt_been_instrumented_p(), instrument_derefs(), maybe_add_sra_candidate(), maybe_instrument_call(), needs_to_live_in_memory(), prepare_call_arguments(), simd_clone_compute_base_data_type(), split_function(), stack_protect_return_slot_p(), use_register_for_decl(), and vectorizable_store().

◆ 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_cleared_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()

rtx assign_stack_local	(	machine_mode	mode,
		poly_int64	size,
		int	align )

extern

Wrap up assign_stack_local_1 with last parameter as false.

References ASLK_RECORD_PAD, and assign_stack_local_1().

Referenced by alter_reg(), assign_mem_slot(), assign_parm_setup_block(), assign_parm_setup_reg(), assign_parm_setup_stack(), assign_parms_unsplit_complex(), emit_stack_save(), expand_builtin_apply(), expand_builtin_apply_args_1(), expand_function_start(), get_arg_pointer_save_area(), get_secondary_mem(), lra(), lra_spill(), reload(), and sjlj_build_landing_pads().

◆ 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(), 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

Allocate a temporary stack slot and record it for possible later
reuse.

MODE is the machine mode to be given to the returned rtx.

SIZE is the size in units of the space required.  We do no rounding here
since assign_stack_local will do any required rounding.

TYPE is the type that will be used for the stack slot.

References adjust_address_nv, temp_slot::align, assign_stack_local_1(), avail_temp_slots, temp_slot::base_offset, cut_slot_from_list(), FRAME_GROWS_DOWNWARD, frame_offset, temp_slot::full_size, gcc_assert, gen_rtx_MEM(), get_alias_set(), GET_MODE, get_stack_local_alignment(), ggc_alloc(), temp_slot::in_use, insert_slot_to_list(), insert_temp_slot_address(), known_eq, known_ge, temp_slot::level, MEM_NOTRAP_P, MEM_VOLATILE_P, n_temp_slots_in_use, temp_slot::next, NULL, objects_must_conflict_p(), set_mem_alias_set(), set_mem_align(), temp_slot::size, temp_slot::slot, stack_slot_list, temp_slot_level, temp_slots_at_level(), temp_slot::type, type(), TYPE_VOLATILE, vec_safe_push(), virtuals_instantiated, and XEXP.

Referenced by assign_stack_temp(), assign_temp(), expand_expr_real_1(), expand_ifn_atomic_compare_exchange_into_call(), and ubsan_encode_value().

◆ 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(), 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()

void clobber_return_register ( void )

extern

References current_function_decl, DECL_RESULT, DECL_RTL, DECL_RTL_SET_P, diddle_return_value(), do_clobber_return_reg(), NULL, REG_P, and REGNO.

Referenced by expand_eh_return(), expand_function_end(), and expand_null_return().

◆ convert_jumps_to_returns()

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

extern

◆ current_function_name()

const char * current_function_name ( void )

extern

Returns the name of the current function.

References cfun, and function_name().

Referenced by adjust_cfg_counts(), create_loop_fn(), df_dump_start(), dump_cfg_stats(), dump_enumerated_decls(), dump_fixup_graph(), initialize_uninitialized_regs(), one_code_hoisting_pass(), one_cprop_pass(), one_pre_gcse_pass(), one_store_motion_pass(), print_loops(), and set_nothrow_function_flags().

◆ diddle_return_value()

void diddle_return_value	(	void(*	doit )(rtx, void *),
		void *	arg )

extern

Call DOIT for each hard register used as a return value from
the current function.

References crtl, and diddle_return_value_1().

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, 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(), initial_value_struct::entries, get_insns(), initial_value_pair::hard_reg, i, initial_value_struct::num_entries, initial_value_pair::pseudo, 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

Undo the effects of init_dummy_function_start.

References cfun, end_sequence(), free_after_compilation(), free_after_parsing(), gcc_assert, in_dummy_function, in_sequence_p(), and pop_dummy_function().

Referenced by backend_init_target().

◆ expand_function_end()

void expand_function_end ( void )

extern

Generate RTL for the end of the current function.

References anti_adjust_stack_and_probe(), arg_pointer_save_area, as_a(), BARRIER_P, BITS_PER_WORD, build_pointer_type(), CALL_P, cfun, clear_pending_stack_adjust(), clobber_return_register(), convert_memory_address, convert_move(), crtl, current_function_decl, DECL_BY_REFERENCE, DECL_REGISTER, DECL_RESULT, DECL_RTL, DECL_RTL_SET_P, do_pending_stack_adjust(), emit_group_load(), emit_group_move(), emit_insn(), emit_insn_after(), emit_insn_before(), emit_label(), emit_move_insn(), emit_stack_restore(), emit_stack_save(), end_sequence(), EXIT_IGNORE_STACK, expand_eh_return(), gcc_assert, gen_blockage(), GEN_INT, gen_reg_rtx(), gen_rtx_REG(), generating_concat_p, GENERIC_STACK_CHECK, get_arg_pointer_save_area(), GET_CODE, get_insns(), get_last_insn(), GET_MODE, GET_MODE_BITSIZE(), global_options, in_sequence_p(), input_location, int_size_in_bytes(), is_complex_int_mode(), naked_return_label, NEXT_INSN(), NULL_RTX, parm_birth_insn, probe_stack_range(), prologue_location, promote_function_mode(), PUT_MODE(), REG_FUNCTION_VALUE_P, REG_P, REGNO, return_label, SAVE_FUNCTION, set_curr_insn_location(), set_insn_locations(), shift_return_value(), sjlj_emit_function_exit_after(), stack_check_probe_note, stack_protect_epilogue(), start_sequence(), targetm, TREE_TYPE, TYPE_EMPTY_P, TYPE_MODE, TYPE_UNSIGNED, UI_SJLJ, use_return_register(), and XEXP.

Referenced by construct_exit_block().

◆ expand_function_start()

void expand_function_start ( tree subr )

extern

References aggregate_value_p(), arg_pointer_rtx, assemble_static_space(), assign_parms(), assign_stack_local(), build4(), build_decl(), cfun, convert_move(), crtl, current_function_decl, current_function_funcdef_no, currently_expanding_function_start, DECL_BY_REFERENCE, DECL_HAS_VALUE_EXPR_P, DECL_MODE, DECL_NAME, DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT, DECL_NO_LIMIT_STACK, DECL_REGISTER, DECL_RESULT, DECL_RTL_SET_P, DECL_SOURCE_LOCATION, emit_move_insn(), emit_note(), expand_expr(), EXPAND_WRITE, function_beg_insn, gcc_assert, gen_group_rtx(), gen_label_rtx(), gen_reg_rtx(), gen_rtx_MEM(), GENERIC_STACK_CHECK, GET_CODE, get_last_insn(), GET_MODE, GET_MODE_SIZE(), hard_frame_pointer_rtx, hard_function_value(), init_recog_no_volatile(), int_size_in_bytes(), integer_zero_node, is_gimple_reg(), mark_reg_pointer(), MEM_P, NOTE_P, NULL, NULL_RTX, NULL_TREE, parm_birth_insn, promote_decl_mode(), promote_ssa_mode(), reg_mentioned_p(), REG_P, return_label, set_decl_incoming_rtl(), SET_DECL_RTL, SET_DECL_VALUE_EXPR, set_dst_reg_note(), set_mem_attributes(), set_parm_rtl(), ssa_default_def(), stack_check_probe_note, stack_limit_rtx, targetm, TREE_OPERAND, TREE_TYPE, TYPE_ALIGN, TYPE_MODE, update_nonlocal_goto_save_area(), and XEXP.

◆ 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(), 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(), 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

Free all temporaries used so far.  This is normally called at the
end of generating code for a statement.

References combine_temp_slots(), make_slot_available(), temp_slot::next, remove_unused_temp_slot_addresses(), temp_slot_level, and temp_slots_at_level().

Referenced by expand_asm_stmt(), expand_case(), expand_gimple_stmt(), expand_sjlj_dispatch_table(), pop_temp_slots(), and stack_protect_epilogue().

◆ function_name()

const char * function_name ( const function * fn )

extern

Returns the name of function FN.

References function::decl, fndecl_name(), and NULL.

Referenced by current_function_name(), dump_function_to_file(), gen_ctf_function_type(), get_function_name(), output_intermediate_json_line(), print_graph_cfg(), and read_graph_file().

◆ generate_setjmp_warnings()

void generate_setjmp_warnings ( void )

extern

Generate warning messages for variables live across setjmp.

References bitmap_empty_p(), cfun, current_function_decl, DECL_INITIAL, n_basic_blocks_for_fn, NUM_FIXED_BLOCKS, regstat_get_setjmp_crosses(), setjmp_args_warning(), setjmp_crosses, and setjmp_vars_warning().

Referenced by ira().

◆ get_arg_pointer_save_area()

rtx get_arg_pointer_save_area ( void )

extern

References arg_pointer_save_area, assign_stack_local(), copy_rtx(), crtl, emit_insn_after(), emit_move_insn(), end_sequence(), entry_of_function(), get_insns(), GET_MODE_SIZE(), pop_topmost_sequence(), push_topmost_sequence(), start_sequence(), and validize_mem().

Referenced by expand_builtin_setjmp_receiver(), and expand_function_end().

◆ 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, initial_value_struct::entries, initial_value_pair::hard_reg, i, NULL_RTX, initial_value_struct::num_entries, initial_value_pair::pseudo, 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, initial_value_struct::entries, gen_reg_rtx(), gen_rtx_REG(), ggc_alloc(), GGC_RESIZEVEC, ggc_vec_alloc(), initial_value_pair::hard_reg, has_hard_reg_initial_val(), initial_value_struct::max_entries, initial_value_struct::num_entries, and initial_value_pair::pseudo.

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

gimple_seq gimplify_parameters ( gimple_seq * cleanup )

extern

Gimplify the parameter list for current_function_decl.  This involves
evaluating SAVE_EXPRs of variable sized parameters and generating code
to implement callee-copies reference parameters.  Returns a sequence of
statements to add to the beginning of the function.

References assign_parm_data_all::args_so_far, assign_parm_data_all::args_so_far_v, assign_parm_find_data_types(), assign_parms_augmented_arg_list(), assign_parms_initialize_all(), build2(), build_alloca_call_expr(), build_clobber(), build_fold_indirect_ref, build_pointer_type(), CALL_ALLOCA_FOR_VAR_P, compare_tree_int(), create_tmp_reg(), create_tmp_var, DECL_ALIGN, DECL_HAS_VALUE_EXPR_P, DECL_IGNORED_P, DECL_NOT_GIMPLE_REG_P, DECL_SIZE, DECL_SIZE_UNIT, fold_convert, FOR_EACH_VEC_ELT, GENERIC_STACK_CHECK, get_name(), gimple_build_assign(), gimple_seq_add_stmt(), gimplify_and_add(), gimplify_assign(), gimplify_one_sizepos(), gimplify_type_sizes(), i, is_gimple_reg(), max_int_size_in_bytes(), NULL, reference_callee_copied(), SET_DECL_VALUE_EXPR, SR_NONE, targetm, TREE_ADDRESSABLE, TREE_CODE, and TREE_TYPE.

Referenced by gimplify_body().

◆ 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, initial_value_struct::entries, GET_MODE, initial_value_pair::hard_reg, i, NULL_RTX, initial_value_struct::num_entries, initial_value_pair::pseudo, 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, initialize_rtl(), prepare_function_start(), TREE_TYPE, and warning_at().

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

◆ init_temp_slots()

void init_temp_slots ( void )

extern

Initialize temporary slots.

References avail_temp_slots, hash_table< Descriptor, Lazy, Allocator >::create_ggc(), n_temp_slots_in_use, temp_slot_address_table, temp_slot_level, used_temp_slots, and vec_alloc().

Referenced by prepare_function_start(), and rest_of_clean_state().

◆ 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, initial_value_struct::entries, initial_value_pair::hard_reg, i, initial_value_struct::num_entries, and initial_value_pair::pseudo.

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

struct loops * loops_for_fn ( struct function * fn )

inline

Return the loop tree of FN.

References function::x_current_loops.

Referenced by analyze_function_body(), copy_cfg_body(), draw_cfg_nodes(), fixup_loop_arrays_after_move(), gate_loop(), get_loop(), get_loops(), init_lowered_empty_function(), loop_optimizer_finalize(), loops_list::loops_list(), loops_state_clear(), loops_state_satisfies_p(), loops_state_set(), move_sese_region_to_fn(), number_of_loops(), place_new_loop(), release_function_body(), release_recorded_exits(), tree_function_versioning(), and tree_optimize_tail_calls_1().

◆ 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, 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

Set BLOCK_NUMBER for all the blocks in FN.

References BLOCK_NUMBER, DECL_INITIAL, free(), get_block_vector(), i, and next_block_index.

Referenced by final_start_function_1(), optimize_inline_calls(), and tree_function_versioning().

◆ pop_cfun()

void pop_cfun ( void )

extern

Pop cfun from the stack.  Also set current_function_decl accordingly.

References cfun, cfun_stack, current_function_decl, function::decl, gcc_checking_assert, in_dummy_function, NULL_TREE, and set_cfun().

Referenced by account_profile_1(), cgraph_node::add_new_function(), cgraph_node::analyze(), analyze_function(), autofdo::auto_profile(), compute_fn_summary(), create_omp_child_function(), create_task_copyfn(), do_per_function_toporder(), estimated_stack_frame_size(), execute_all_ipa_transforms(), execute_function_dump(), execute_function_todo(), execute_one_pass(), cgraph_node::expand(), expand_omp_target(), expand_omp_taskreg(), finalize_task_copyfn(), function_and_variable_visibility(), cgraph_node::get_body(), gimplify_function_tree(), inline_analyze_function(), input_function(), modref_summaries::insert(), modref_summaries_lto::insert(), ipa_analyze_node(), ipa_merge_profiles(), ipa_sra_summarize_function(), ipa_tm_execute(), ipa_tm_scan_irr_function(), ipa_tm_transform_clone(), ipa_tm_transform_transaction(), lower_assumption(), lower_emutls_function_body(), lto_prepare_function_for_streaming(), move_block_to_fn(), move_sese_region_to_fn(), pop_dummy_function(), symbol_table::process_new_functions(), cgraph_edge::redirect_call_stmt_to_callee(), ipa_icf_gimple::func_checker::safe_for_total_scalarization_p(), simd_clone_adjust(), tree_function_versioning(), tree_profiling(), and auto_cfun::~auto_cfun().

◆ pop_dummy_function()

void pop_dummy_function ( void )

extern

References in_dummy_function, and pop_cfun().

Referenced by gcc::pass_manager::dump_passes(), and expand_dummy_function_end().

◆ 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

Pop a temporary nesting level.  All slots in use in the current level
are freed.

References free_temp_slots(), and temp_slot_level.

Referenced by emit_library_call_value_1(), expand_addsub_overflow(), expand_assignment(), expand_mul_overflow(), expand_neg_overflow(), precompute_register_parameters(), rtx_for_function_call(), and store_one_arg().

◆ 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

References contains(), epilogue_insn_hash, and prologue_insn_hash.

◆ push_cfun()

void push_cfun ( struct function * new_cfun )

extern

Push the current cfun onto the stack, and set cfun to new_cfun.  Also set
current_function_decl accordingly.

References cfun, cfun_stack, current_function_decl, function::decl, gcc_assert, NULL_TREE, and set_cfun().

Referenced by account_profile_1(), cgraph_node::add_new_function(), cgraph_node::analyze(), analyze_function(), auto_cfun::auto_cfun(), autofdo::auto_profile(), compute_fn_summary(), create_task_copyfn(), do_per_function_toporder(), estimated_stack_frame_size(), execute_all_ipa_transforms(), execute_function_dump(), execute_function_todo(), cgraph_node::expand(), expand_omp_target(), expand_omp_taskreg(), finalize_task_copyfn(), function_and_variable_visibility(), cgraph_node::get_body(), gimplify_function_tree(), inline_analyze_function(), modref_summaries::insert(), modref_summaries_lto::insert(), ipa_analyze_node(), ipa_merge_profiles(), ipa_sra_summarize_function(), ipa_tm_execute(), ipa_tm_scan_irr_function(), ipa_tm_transform_clone(), ipa_tm_transform_transaction(), lower_emutls_function_body(), lto_prepare_function_for_streaming(), move_block_to_fn(), move_sese_region_to_fn(), symbol_table::process_new_functions(), cgraph_edge::redirect_call_stmt_to_callee(), ipa_icf_gimple::func_checker::safe_for_total_scalarization_p(), simd_clone_adjust(), and tree_profiling().

◆ push_dummy_function()

void push_dummy_function ( bool with_decl )

extern

References build_decl(), build_function_type_list(), DECL_ARTIFICIAL, DECL_RESULT, gcc_assert, get_identifier(), in_dummy_function, NULL_TREE, push_struct_function(), SET_DECL_ASSEMBLER_NAME, UNKNOWN_LOCATION, and void_type_node.

Referenced by gcc::pass_manager::dump_passes(), and init_dummy_function_start().

◆ 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, 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()

void push_temp_slots ( void )

extern

Push deeper into the nesting level for stack temporaries.

References temp_slot_level.

Referenced by emit_library_call_value_1(), expand_addsub_overflow(), expand_assignment(), expand_mul_overflow(), expand_neg_overflow(), precompute_register_parameters(), rtx_for_function_call(), and store_one_arg().

◆ 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_strdup, callinfo_dalloc::location, callinfo_dalloc::name, NULL, and vec_safe_push().

Referenced by expand_builtin_alloca(), and gimplify_vla_decl().

◆ record_epilogue_seq()

void record_epilogue_seq ( rtx_insn * seq )

extern

References epilogue_insn_hash, NULL, and record_insns().

Referenced by emit_common_heads_for_components(), emit_common_tails_for_components(), and insert_prologue_epilogue_for_components().

◆ record_final_call()

void record_final_call	(	tree	callee,
		location_t	location )

Record a final call to CALLEE at LOCATION.

References cfun, and vec_safe_push().

Referenced by emit_library_call_value_1(), and expand_call().

◆ record_prologue_seq()

void record_prologue_seq ( rtx_insn * seq )

extern

References NULL, prologue_insn_hash, and record_insns().

Referenced by emit_common_heads_for_components(), emit_common_tails_for_components(), and insert_prologue_epilogue_for_components().

◆ 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(), 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(), LABEL_P, last, NEXT_INSN(), NOTE_KIND, NOTE_P, NULL, PREV_INSN(), prologue_insn_hash, reorder_insns(), and targetm.

◆ set_cfun()

void set_cfun	(	struct function *	new_cfun,
		bool	force )

extern

cfun shouldn't be set directly; use one of these functions instead.

cfun should never be set directly; use this function.

References cfun, function::decl, invoke_set_current_function_hook(), NULL_TREE, and redirect_edge_var_map_empty().

Referenced by cgraph_build_static_cdtor_1(), cgraph_debug_gimple_stmt(), create_loop_fn(), cgraph_node::create_wrapper(), expand_thunk(), symbol_table::finalize_compilation_unit(), finalize_size_functions(), inline_call(), ipa_passes(), pop_cfun(), pop_function_context(), push_cfun(), and push_function_context().

◆ set_loops_for_fn()

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

inline

Set the loop tree of FN to LOOPS.

References gcc_checking_assert, NULL, and function::x_current_loops.

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

◆ 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, 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(), 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 as_a(), basic_block_def::aux, 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(), basic_block_def::index, insert_insn_on_edge(), last, last_basic_block_for_fn, make_epilogue_seq(), make_prologue_seq(), make_split_prologue_seq(), next_active_insn(), basic_block_def::next_bb, 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 )

Inserts an entry into the types_used_by_vars_hash hash table.

References hash_table< Descriptor, Lazy, Allocator >::create_ggc(), ggc_alloc(), NULL, type(), types_used_by_vars_entry::type, types_used_by_vars_hash, and types_used_by_vars_entry::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, 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()

bool use_register_for_decl ( const_tree decl )

extern

Return true if we should assign DECL a pseudo register; false if it
should live on the local stack.

References aggregate_value_p(), cfun, current_function_decl, DECL_BY_REFERENCE, DECL_IGNORED_P, DECL_MODE, DECL_REGISTER, FLOAT_TYPE_P, RECORD_OR_UNION_TYPE_P, SSA_NAME_VAR, targetm, TREE_ADDRESSABLE, TREE_CODE, TREE_SIDE_EFFECTS, TREE_TYPE, and TYPE_MODE.

Referenced by assign_parm_setup_block(), assign_parm_setup_reg(), assign_parms(), avoid_type_punning_on_regs(), discover_nonconstant_array_refs(), expand_one_ssa_partition(), expand_one_var(), gimple_can_coalesce_p(), and set_rtl().

◆ used_types_insert()

void used_types_insert ( tree t )

extern

Given a type, insert it into the used hash table in cfun.

References cfun, DINFO_LEVEL_NONE, NULL_TREE, POINTER_TYPE_P, TREE_CODE, TREE_TYPE, TYPE_MAIN_VARIANT, TYPE_NAME, types_used_by_cur_var_decl, used_types_insert_helper(), and vec_safe_push().

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

Data Structures

Macros

Typedefs

Enumerations

Functions

Variables

Macro Definition Documentation

◆ ADD_PARM_SIZE

◆ apply_args_value

◆ ARGS_SIZE_RTX

◆ ARGS_SIZE_TREE

◆ ASLK_RECORD_PAD

◆ ASLK_REDUCE_ALIGN

◆ cfun

◆ current_function_allocates_dynamic_stack_space

◆ current_function_dynamic_stack_size

◆ current_function_funcdef_no

◆ current_function_has_unbounded_dynamic_stack_size

◆ current_function_pushed_stack_size

◆ current_function_static_stack_size

◆ current_loops

◆ dom_computed

◆ FOR_EACH_LOCAL_DECL

◆ forced_labels

◆ inhibit_defer_pop

◆ MINIMUM_METHOD_BOUNDARY

◆ n_bbs_in_dom_tree

◆ pending_stack_adjust

◆ reg_rtx_no

◆ REGNO_POINTER_ALIGN

◆ saveregs_value

◆ stack_pointer_delta

◆ SUB_PARM_SIZE

◆ VA_LIST_MAX_FPR_SIZE

◆ VA_LIST_MAX_GPR_SIZE

◆ VALUE_HISTOGRAMS

Typedef Documentation

◆ call_site_record

Enumeration Type Documentation

◆ stack_clash_probes

Function Documentation

◆ active_insn_between()

◆ add_local_decl()

◆ aggregate_value_p()

◆ allocate_struct_function()

◆ assign_stack_local()

◆ assign_stack_local_1()

◆ assign_stack_temp()

◆ assign_stack_temp_for_type()

◆ assign_temp()

◆ block_chainon()

◆ blocks_nreverse()

◆ clear_block_marks()

◆ clobber_return_register()

◆ convert_jumps_to_returns()

◆ current_function_name()

◆ diddle_return_value()

◆ dump_stack_clash_frame_info()

◆ emit_initial_value_sets()

◆ emit_return_for_exit()

◆ emit_return_into_block()

◆ epilogue_contains()

◆ expand_dummy_function_end()

◆ expand_function_end()

◆ expand_function_start()

◆ fndecl_name()

◆ frame_offset_overflow()

◆ free_after_compilation()

◆ free_after_parsing()

◆ free_temp_slots()

◆ function_name()

◆ generate_setjmp_warnings()

◆ get_arg_pointer_save_area()

◆ get_frame_size()

◆ get_hard_reg_initial_reg()

◆ get_hard_reg_initial_val()

◆ get_last_funcdef_no()

◆ get_new_clique()

◆ get_next_funcdef_no()

◆ get_stack_dynamic_offset()