regs.h File Reference

Go to the source code of this file.

Data Structures
struct	regstat_n_sets_and_refs_t
struct	reg_info_t
struct	target_regs

Macros
#define	REG_BYTES(R)
#define	REGMODE_NATURAL_SIZE(MODE)
#define	SET_REG_N_REFS(N, V)
#define	INC_REG_N_REFS(N, V)
#define	SET_REG_N_SETS(N, V)
#define	INC_REG_N_SETS(N, V)
#define	REG_FREQ(N)
#define	REG_FREQ_MAX   1000
#define	REG_FREQ_FROM_BB(bb)
#define	REG_N_DEATHS(N)
#define	PSEUDO_REGNO_SIZE(N)
#define	PSEUDO_REGNO_BYTES(N)
#define	PSEUDO_REGNO_MODE(N)
#define	REG_N_CALLS_CROSSED(N)
#define	REG_BLOCK_UNKNOWN   0
#define	REG_BLOCK_GLOBAL   -1
#define	REG_BASIC_BLOCK(N)
#define	HARD_REGNO_CALLER_SAVE_MODE(REGNO, NREGS, MODE)
#define	this_target_regs   (&default_target_regs)
#define	hard_regno_max_nregs    (this_target_regs->x_hard_regno_max_nregs)
#define	reg_raw_mode    (this_target_regs->x_reg_raw_mode)
#define	have_regs_of_mode    (this_target_regs->x_have_regs_of_mode)
#define	contains_reg_of_mode    (this_target_regs->x_contains_reg_of_mode)
#define	contains_allocatable_reg_of_mode    (this_target_regs->x_contains_allocatable_reg_of_mode)
#define	direct_load    (this_target_regs->x_direct_load)
#define	direct_store    (this_target_regs->x_direct_store)
#define	float_extend_from_mem    (this_target_regs->x_float_extend_from_mem)

Functions
int	REG_N_REFS (int regno)
int	REG_N_SETS (int regno)
bool	reg_is_parm_p (rtx)
void	regstat_init_n_sets_and_refs (void)
void	regstat_free_n_sets_and_refs (void)
void	regstat_compute_ri (void)
void	regstat_free_ri (void)
bitmap	regstat_get_setjmp_crosses (void)
void	regstat_compute_calls_crossed (void)
void	regstat_free_calls_crossed (void)
void	dump_reg_info (FILE *)
ALWAYS_INLINE unsigned char	hard_regno_nregs (unsigned int regno, machine_mode mode)
unsigned int	end_hard_regno (machine_mode mode, unsigned int regno)
void	add_to_hard_reg_set (HARD_REG_SET *regs, machine_mode mode, unsigned int regno)
void	remove_from_hard_reg_set (HARD_REG_SET *regs, machine_mode mode, unsigned int regno)
bool	in_hard_reg_set_p (const_hard_reg_set regs, machine_mode mode, unsigned int regno)
bool	overlaps_hard_reg_set_p (const_hard_reg_set regs, machine_mode mode, unsigned int regno)
void	add_range_to_hard_reg_set (HARD_REG_SET *regs, unsigned int regno, int nregs)
void	remove_range_from_hard_reg_set (HARD_REG_SET *regs, unsigned int regno, int nregs)
bool	range_overlaps_hard_reg_set_p (const_hard_reg_set set, unsigned regno, int nregs)
bool	range_in_hard_reg_set_p (const_hard_reg_set set, unsigned regno, int nregs)

Variables
int	max_regno
struct regstat_n_sets_and_refs_t *	regstat_n_sets_and_refs
struct reg_info_t *	reg_info_p
size_t	reg_info_p_size
short *	reg_renumber
int	caller_save_needed
struct target_regs	default_target_regs

Macro Definition Documentation

contains_allocatable_reg_of_mode

#define contains_allocatable_reg_of_mode    (this_target_regs->x_contains_allocatable_reg_of_mode)

Referenced by init_reg_sets_1(), and push_reload().

contains_reg_of_mode

#define contains_reg_of_mode    (this_target_regs->x_contains_reg_of_mode)

Referenced by init_reg_sets_1(), restrict_cost_classes(), setup_pressure_classes(), and setup_uniform_class_p().

direct_load

#define direct_load    (this_target_regs->x_direct_load)

Referenced by convert_mode_scalar(), convert_modes(), expand_expr_real_1(), and init_expr_target().

direct_store

#define direct_store    (this_target_regs->x_direct_store)

Referenced by init_expr_target(), and store_field().

float_extend_from_mem

#define float_extend_from_mem    (this_target_regs->x_float_extend_from_mem)

Referenced by compress_float_constant(), and init_expr_target().

HARD_REGNO_CALLER_SAVE_MODE

#define HARD_REGNO_CALLER_SAVE_MODE	(		REGNO,
			NREGS,
			MODE )

Value:

  choose_hard_reg_mode (REGNO, NREGS, NULL)

Select a register mode required for caller save of hard regno REGNO.   

Referenced by init_caller_save(), save_call_clobbered_regs(), and split_reg().

hard_regno_max_nregs

#define hard_regno_max_nregs    (this_target_regs->x_hard_regno_max_nregs)

Referenced by zcur_select_mode_rtx().

have_regs_of_mode

#define have_regs_of_mode    (this_target_regs->x_have_regs_of_mode)

Referenced by bitwise_mode_for_mode(), bitwise_mode_for_size(), init_reg_sets_1(), mode_for_vector(), scan_one_insn(), and vector_type_mode().

INC_REG_N_REFS

#define INC_REG_N_REFS	(		N,
			V )

Value:

(regstat_n_sets_and_refs[N].refs += V)

INC_REG_N_SETS

#define INC_REG_N_SETS	(		N,
			V )

Value:

(regstat_n_sets_and_refs[N].sets += V)

Referenced by try_combine().

PSEUDO_REGNO_BYTES

#define PSEUDO_REGNO_BYTES

(

N

)

Value:

  GET_MODE_SIZE (PSEUDO_REGNO_MODE (N))

Get the number of bytes required to hold pseudo-reg N.   

Referenced by assign_mem_slot(), dump_reg_info(), ira_mark_new_stack_slot(), and ira_reuse_stack_slot().

PSEUDO_REGNO_MODE

#define PSEUDO_REGNO_MODE

(

N

)

Value:

GET_MODE (regno_reg_rtx[N])

Get the machine mode of pseudo-reg N.   

Referenced by add_pseudo_to_slot(), assign_by_spills(), assign_spill_hard_regs(), assign_stack_slot_num_and_sort_pseudos(), calculate_equiv_gains(), check_pseudos_live_through_calls(), coalesced_pseudo_reg_slot_compare(), compute_use_by_pseudos(), count_pseudo(), count_spilled_pseudo(), curr_insn_transform(), find_costs_and_classes(), find_hard_regno_for_1(), get_regno_pressure_class(), get_regno_pressure_class(), inherit_in_ebb(), ira_create_allocno(), ira_implicitly_set_insn_hard_regs(), ira_sort_regnos_for_alter_reg(), lra_assign(), lra_constraints(), lra_fp_pseudo_p(), lra_setup_reg_renumber(), mark_home_live(), need_for_call_save_p(), save_call_clobbered_regs(), setup_live_pseudos_and_spill_after_risky_transforms(), setup_next_usage_insn(), setup_regno_cost_classes_by_aclass(), setup_save_areas(), setup_try_hard_regno_pseudos(), spill_for(), spill_hard_reg(), spill_pseudos(), split_reg(), and track_loc_p().

PSEUDO_REGNO_SIZE

#define PSEUDO_REGNO_SIZE

(

N

)

Value:

  ((GET_MODE_SIZE (PSEUDO_REGNO_MODE (N)) + UNITS_PER_WORD - 1)         \
   / UNITS_PER_WORD)

Get the number of consecutive words required to hold pseudo-reg N.   

REG_BASIC_BLOCK

#define REG_BASIC_BLOCK

(

N

)

Value:

(reg_info_p[N].basic_block)

Referenced by add_store_equivs(), combine_and_move_insns(), delete_output_reload(), dump_reg_info(), equiv_init_movable_p(), regstat_bb_compute_ri(), regstat_compute_ri(), and update_equiv_regs().

REG_BLOCK_GLOBAL

#define REG_BLOCK_GLOBAL   -1

Referenced by regstat_bb_compute_ri().

REG_BLOCK_UNKNOWN

#define REG_BLOCK_UNKNOWN   0

Indexed by n, gives number of basic block that  (REG n) is used in.
If the value is REG_BLOCK_GLOBAL (-1),
it means (REG n) is used in more than one basic block.
REG_BLOCK_UNKNOWN (0) means it hasn't been seen yet so we don't know.
This information remains valid for the rest of the compilation
of the current function; it is used to control register allocation.   

Referenced by regstat_bb_compute_ri(), and regstat_compute_ri().

REG_BYTES

#define REG_BYTES

(

R

)

Value:

mode_size[(int) GET_MODE (R)]

Define per-register tables for data flow info and register allocation.
   Copyright (C) 1987-2024 Free Software Foundation, Inc.

This file is part of GCC.

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

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

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

REG_FREQ

#define REG_FREQ

(

N

)

Value:

(reg_info_p[N].freq)

Estimate frequency of references to register N.   

Referenced by combine_and_move_insns(), count_pseudo(), count_spilled_pseudo(), ira_mark_new_stack_slot(), ira_reuse_stack_slot(), pseudo_reg_compare(), and regstat_bb_compute_ri().

REG_FREQ_FROM_BB

#define REG_FREQ_FROM_BB

(

bb

)

Value:

                               ((optimize_function_for_size_p (cfun)          \
                               || !cfun->cfg->count_max.initialized_p ())     \
                              ? REG_FREQ_MAX                                  \
                              : ((bb)->count.to_frequency (cfun)              \
                                * REG_FREQ_MAX / BB_FREQ_MAX)                 \
                              ? ((bb)->count.to_frequency (cfun)              \
                                 * REG_FREQ_MAX / BB_FREQ_MAX)                \
                              : 1)

Compute register frequency from the BB frequency.  When optimizing for size,
or profile driven feedback is available and the function is never executed,
frequency is always equivalent.  Otherwise rescale the basic block
frequency.   

Referenced by add_insn_allocno_copies(), add_ranges_and_copies(), assign_hard_reg(), calculate_elim_costs_all_insns(), calculate_equiv_gains(), calculate_spill_cost(), create_insn_allocnos(), emit_moves(), find_hard_regno_for_1(), get_insn_freq(), improve_allocation(), lra_coalesce(), lra_constraints(), move_freq_compare_func(), note_reg_elim_costly(), process_bb_for_costs(), process_bb_lives(), process_bb_node_for_hard_reg_moves(), process_bb_node_lives(), record_reg_classes(), regstat_bb_compute_ri(), scan_one_insn(), setup_save_areas(), and spill_for().

REG_FREQ_MAX

#define REG_FREQ_MAX   1000

The weights for each insn varies from 0 to REG_FREQ_BASE.
This constant does not need to be high, as in infrequently executed
regions we want to count instructions equivalently to optimize for
size instead of speed.   

Referenced by regstat_bb_compute_ri().

REG_N_CALLS_CROSSED

#define REG_N_CALLS_CROSSED

(

N

)

Value:

(reg_info_p[N].calls_crossed)

Indexed by N, gives number of CALL_INSNS across which (REG n) is live.   

Referenced by combine_and_move_insns(), dump_reg_info(), regstat_bb_compute_calls_crossed(), and regstat_bb_compute_ri().

REG_N_DEATHS

#define REG_N_DEATHS

(

N

)

Value:

(reg_info_p[N].deaths)

Indexed by N, gives number of insns in which register N dies.
Note that if register N is live around loops, it can die
in transitions between basic blocks, and that is not counted here.
So this is only a reliable indicator of how many regions of life there are
for registers that are contained in one basic block.   

Referenced by delete_output_reload(), dump_reg_info(), emit_input_reload_insns(), and regstat_bb_compute_ri().

reg_raw_mode

#define reg_raw_mode    (this_target_regs->x_reg_raw_mode)

Referenced by asm_clobber_reg_is_valid(), cselib_preserve_only_values(), default_dwarf_frame_reg_mode(), default_get_reg_raw_mode(), distribute_notes(), expand_asm_stmt(), gen_rtx_REG(), inherit_piecemeal_p(), init_emit_regs(), init_reg_modes_target(), lra_update_biggest_mode(), and rtx_properties::try_to_add_insn().

REGMODE_NATURAL_SIZE

#define REGMODE_NATURAL_SIZE

(

MODE

)

Value:

UNITS_PER_WORD

When you only have the mode of a pseudo register before it has a hard
register chosen for it, this reports the size of each hard register
a pseudo in such a mode would get allocated to.  A target may
override this.   

Referenced by can_change_dest_mode(), expand_clobber(), gen_lowpart_common(), go_through_subreg(), lowpart_bit_field_p(), read_modify_subreg_p(), record_subregs_of_mode(), store_bit_field_1(), store_constructor(), and validate_subreg().

SET_REG_N_REFS

#define SET_REG_N_REFS	(		N,
			V )

Value:

(regstat_n_sets_and_refs[N].refs = V)

Indexed by n, gives number of times (REG n) is used or set.   

Referenced by combine_and_move_insns(), move_unallocated_pseudos(), and regstat_init_n_sets_and_refs().

SET_REG_N_SETS

#define SET_REG_N_SETS	(		N,
			V )

Value:

(regstat_n_sets_and_refs[N].sets = V)

Indexed by n, gives number of times (REG n) is set.   

Referenced by regstat_init_n_sets_and_refs().

this_target_regs

#define this_target_regs   (&default_target_regs)

Referenced by hard_regno_nregs(), and init_reg_modes_target().

Function Documentation

add_range_to_hard_reg_set()

void add_range_to_hard_reg_set ( HARD_REG_SET * regs, unsigned int regno, int nregs )

inline

Like add_to_hard_reg_set, but use a REGNO/NREGS range instead of
REGNO and MODE.   

References SET_HARD_REG_BIT.

Referenced by asm_clobber_reg_is_valid().

add_to_hard_reg_set()

void add_to_hard_reg_set ( HARD_REG_SET * regs, machine_mode mode, unsigned int regno )

inline

Add to REGS all the registers required to store a value of mode MODE
in register REGNO.   

References end_hard_regno(), and SET_HARD_REG_BIT.

Referenced by assign_spill_hard_regs(), choose_reload_regs(), clarify_prohibited_class_mode_regs(), compute_regs_asm_clobbered(), compute_use_by_pseudos(), expand_expr_real_1(), find_all_hard_regs(), find_hard_regno_for_1(), inherit_in_ebb(), insert_with_costs(), ira_implicitly_set_insn_hard_regs(), lra_fp_pseudo_p(), lra_update_fp2sp_elimination(), mark_referenced_resources(), mark_reg_as_referenced(), mark_reload_reg_in_use(), mark_set_resources(), mark_target_live_regs(), mark_used_regs_combine(), note_sets_clobbers(), peep2_find_free_register(), process_alt_operands(), record_hard_reg_sets(), rename_chains(), requires_stack_frame_p(), scan_loop(), setup_alloc_regs(), setup_live_pseudos_and_spill_after_risky_transforms(), try_shrink_wrapping(), and update_reg_eliminate().

dump_reg_info()

void dump_reg_info ( FILE * file )

extern

Dump the register info to FILE.   

References df, DF_REG_DEF_COUNT, DF_REG_USE_COUNT, i, max_reg_num(), NULL, NUM_FIXED_BLOCKS, print_dec(), PSEUDO_REGNO_BYTES, reg_alternate_class(), REG_BASIC_BLOCK, reg_class_names, reg_info_p_size, REG_N_CALLS_CROSSED, REG_N_DEATHS, REG_N_REFS(), REG_N_SETS(), REG_POINTER, reg_preferred_class(), REG_USERVAR_P, regno_reg_rtx, regstat_n_sets_and_refs, reload_completed, and SIGNED.

Referenced by compute_alignments(), reorder_basic_blocks(), rest_of_handle_if_conversion(), rtl_loop_init(), and variable_tracking_main_1().

end_hard_regno()

unsigned int end_hard_regno ( machine_mode mode, unsigned int regno )

inline

Return an exclusive upper bound on the registers occupied by hard
register (reg:MODE REGNO).   

References hard_regno_nregs().

Referenced by add_stored_regs(), add_to_hard_reg_set(), assign_hard_reg(), clear_reload_reg_in_use(), clear_sparseset_regnos(), collect_non_operand_hard_regs(), cselib_invalidate_regno(), decompose(), emit_note_insn_var_location(), find_equiv_reg(), find_hard_regno_for_1(), hard_reg_set_here_p(), improve_allocation(), in_hard_reg_set_p(), mark_home_live_1(), mark_regno_dead(), mark_regno_live(), move2add_valid_value_p(), operand_to_remat(), overlaps_hard_reg_set_p(), push_reload(), record_reg_sets(), reg_bitfield_target_p(), regno_clobbered_p(), regnos_in_sparseset_p(), reload_combine_note_store(), remove_from_hard_reg_set(), and spill_hard_reg().

hard_regno_nregs()

ALWAYS_INLINE unsigned char hard_regno_nregs	(	unsigned int	regno,
		machine_mode	mode )

Return the number of hard registers in (reg:MODE REGNO).   

References this_target_regs, and target_regs::x_hard_regno_nregs.

Referenced by add_removable_extension(), aggregate_value_p(), allocate_reload_reg(), assign_hard_reg(), assign_hard_regno(), assign_spill_hard_regs(), calculate_saved_nregs(), can_change_dest_mode(), check_hard_reg_p(), check_new_reg_p(), choose_hard_reg_mode(), choose_reload_regs(), clarify_prohibited_class_mode_regs(), clear_reload_reg_in_use(), combine_reaching_defs(), combine_reloads(), copy_value(), copyprop_hardreg_forward_1(), count_pseudo(), count_spilled_pseudo(), cselib_lookup_1(), cselib_reset_table(), dead_debug_insert_temp(), default_zero_call_used_regs(), delete_output_reload(), distribute_notes(), do_remat(), emit_note_insn_var_location(), emit_reload_insns(), end_hard_regno(), enough_allocatable_hard_regs_p(), find_dummy_reload(), find_equiv_reg(), find_hard_regno_for_1(), find_oldest_value_reg(), find_reg(), find_reloads(), free_for_value_p(), get_hard_regs(), improve_allocation(), inherit_in_ebb(), init_reg_modes_target(), predefined_function_abi::initialize(), insert_restore(), insert_save(), invariant_p(), ira_hard_reg_in_set_p(), ira_hard_reg_set_intersection_p(), ira_setup_eliminable_regset(), kill_value_regno(), lra_constraint_offset(), lra_constraints(), lra_setup_reg_renumber(), make_decl_rtl(), match_reload(), maybe_mode_change(), modify_move_list(), move_deaths(), non_conflicting_reg_copy_p(), operands_match_p(), peep2_find_free_register(), push_reload(), reg_overlap_for_remat_p(), regrename_do_replace(), reload_adjust_reg_for_mode(), reload_adjust_reg_for_temp(), reload_combine_recognize_pattern(), replace_reg_with_saved_mem(), save_call_clobbered_regs(), set_mode_and_regno(), set_value_regno(), setup_live_pseudos_and_spill_after_risky_transforms(), setup_profitable_hard_regs(), setup_reg_mode_hard_regset(), setup_save_areas(), setup_try_hard_regno_pseudos(), simplify_operand_subreg(), spill_for(), spill_soft_conflicts(), split_if_necessary(), split_reg(), store_integral_bit_field(), subreg_get_info(), track_loc_p(), and vectorizable_store().

in_hard_reg_set_p()

bool in_hard_reg_set_p ( const_hard_reg_set regs, machine_mode mode, unsigned int regno )

inline

Return true if REGS contains the whole of (reg:MODE REGNO).   

References end_hard_regno(), gcc_assert, HARD_REGISTER_NUM_P, and TEST_HARD_REG_BIT.

Referenced by asm_clobber_reg_is_valid(), calculate_spill_cost(), find_equiv_reg(), find_oldest_value_reg(), find_valid_class_1(), general_operand(), ira_build_conflicts(), make_decl_rtl(), process_alt_operands(), push_reload(), record_operand_costs(), reg_fits_class_p(), setup_prohibited_and_exclude_class_mode_regs(), and simplify_operand_subreg().

overlaps_hard_reg_set_p()

bool overlaps_hard_reg_set_p ( const_hard_reg_set regs, machine_mode mode, unsigned int regno )

inline

Return true if (reg:MODE REGNO) includes an element of REGS.   

References end_hard_regno(), and TEST_HARD_REG_BIT.

Referenced by asm_clobber_reg_is_valid(), assign_spill_hard_regs(), call_clobbered_in_region_p(), function_abi::clobbers_reg_p(), predefined_function_abi::clobbers_reg_p(), contains_reg_p(), decl_overlaps_hard_reg_set_p(), find_hard_regno_for_1(), predefined_function_abi::initialize(), invalidate_for_call(), lra_assign(), lra_fp_pseudo_p(), move_insn_for_shrink_wrap(), setup_live_pseudos_and_spill_after_risky_transforms(), setup_try_hard_regno_pseudos(), simplify_operand_subreg(), spill_pseudos(), and uses_hard_regs_p().

range_in_hard_reg_set_p()

bool range_in_hard_reg_set_p ( const_hard_reg_set set, unsigned regno, int nregs )

inline

Like in_hard_reg_set_p, but use a REGNO/NREGS range instead of
REGNO and MODE.   

References TEST_HARD_REG_BIT.

Referenced by init_rename_info().

range_overlaps_hard_reg_set_p()

bool range_overlaps_hard_reg_set_p ( const_hard_reg_set set, unsigned regno, int nregs )

inline

Like overlaps_hard_reg_set_p, but use a REGNO/NREGS range instead of
REGNO and MODE.   

References TEST_HARD_REG_BIT.

Referenced by regrename_analyze().

reg_is_parm_p()

bool reg_is_parm_p ( rtx reg )

extern

Given a REG, return TRUE if the reg is a PARM_DECL, FALSE otherwise.   

Return TRUE if REG is a PARM_DECL, FALSE otherwise.   

References gcc_assert, REG_EXPR, REG_P, and TREE_CODE.

Referenced by ira_build_conflicts().

REG_N_REFS()

int REG_N_REFS ( int regno )

inline

Indexed by n, gives number of times (REG n) is used or set.   

References regstat_n_sets_and_refs_t::refs, and regstat_n_sets_and_refs.

Referenced by alter_reg(), calculate_spill_cost(), dump_reg_info(), print_pseudo_costs(), and update_equiv_regs().

REG_N_SETS()

int REG_N_SETS ( int regno )

inline

Indexed by n, gives number of times (REG n) is set.   

References regstat_n_sets_and_refs, and regstat_n_sets_and_refs_t::sets.

Referenced by allocate_initial_values(), can_change_dest_mode(), delete_output_reload(), dump_reg_info(), emit_input_reload_insns(), get_last_value(), get_last_value_validate(), reg_nonzero_bits_for_combine(), reg_num_sign_bit_copies_for_combine(), regno_clobbered_at_setjmp(), regstat_init_n_sets_and_refs(), and scan_one_insn().

regstat_compute_calls_crossed()

void regstat_compute_calls_crossed ( void )

extern

Compute register info: lifetime, bb, and number of defs and uses.   

References BITMAP_ALLOC, BITMAP_FREE, cfun, df_bitmap_obstack, FOR_EACH_BB_FN, gcc_assert, basic_block_def::index, max_reg_num(), max_regno, reg_info_p, reg_info_p_size, regstat_bb_compute_calls_crossed(), timevar_pop(), and timevar_push().

regstat_compute_ri()

void regstat_compute_ri ( void )

extern

Compute register info: lifetime, bb, and number of defs and uses.   

References BITMAP_ALLOC, BITMAP_FREE, cfun, df_bitmap_obstack, EXECUTE_IF_SET_IN_BITMAP, FOR_EACH_BB_FN, gcc_assert, max_reg_num(), max_regno, REG_BASIC_BLOCK, REG_BLOCK_UNKNOWN, reg_info_p, reg_info_p_size, regstat_bb_compute_ri(), setjmp_crosses, timevar_pop(), and timevar_push().

Referenced by find_moveable_pseudos(), and ira().

regstat_free_calls_crossed()

void regstat_free_calls_crossed ( void )

extern

Free all storage associated with the problem.   

References free(), gcc_assert, NULL, reg_info_p, and reg_info_p_size.

regstat_free_n_sets_and_refs()

void regstat_free_n_sets_and_refs ( void )

extern

Free the array that holds the REG_N_SETS and REG_N_REFS.   

References free(), gcc_assert, NULL, and regstat_n_sets_and_refs.

Referenced by do_reload(), find_moveable_pseudos(), ira(), lra(), move_loop_invariants(), one_code_hoisting_pass(), and rest_of_handle_combine().

regstat_free_ri()

void regstat_free_ri ( void )

extern

Free all storage associated with the problem.   

References BITMAP_FREE, free(), gcc_assert, NULL, reg_info_p, reg_info_p_size, and setjmp_crosses.

Referenced by do_reload(), find_moveable_pseudos(), ira(), and lra().

regstat_get_setjmp_crosses()

bitmap regstat_get_setjmp_crosses ( void )

extern

Return a bitmap containing the set of registers that cross a setjmp.
The client should not change or delete this bitmap.   

References setjmp_crosses.

Referenced by assign_spill_hard_regs(), coalesce_spill_slots(), generate_setjmp_warnings(), and update_equiv_regs().

regstat_init_n_sets_and_refs()

void regstat_init_n_sets_and_refs ( void )

extern

Functions defined in regstat.cc.   

If a pass need to change these values in some magical way or the
pass needs to have accurate values for these and is not using
incremental df scanning, then it should use REG_N_SETS and
REG_N_USES.  If the pass is doing incremental scanning then it
should be getting the info from DF_REG_DEF_COUNT and
DF_REG_USE_COUNT.   

References DEBUG_INSN_P, df_grow_reg_info(), DF_REF_INSN, DF_REF_INSN_INFO, DF_REF_NEXT_REG, DF_REG_DEF_COUNT, DF_REG_USE_CHAIN, DF_REG_USE_COUNT, gcc_assert, i, max_reg_num(), max_regno, MAY_HAVE_DEBUG_BIND_INSNS, REG_N_SETS(), regstat_n_sets_and_refs, SET_REG_N_REFS, SET_REG_N_SETS, timevar_pop(), and timevar_push().

Referenced by find_moveable_pseudos(), ira(), move_loop_invariants(), one_code_hoisting_pass(), and rest_of_handle_combine().

remove_from_hard_reg_set()

void remove_from_hard_reg_set ( HARD_REG_SET * regs, machine_mode mode, unsigned int regno )

inline

Likewise, but remove the registers.   

References CLEAR_HARD_REG_BIT, and end_hard_regno().

Referenced by build_def_use(), inherit_in_ebb(), predefined_function_abi::initialize(), mark_target_live_regs(), and setup_next_usage_insn().

remove_range_from_hard_reg_set()

void remove_range_from_hard_reg_set ( HARD_REG_SET * regs, unsigned int regno, int nregs )

inline

Likewise, but remove the registers.   

References CLEAR_HARD_REG_BIT.

Referenced by init_rename_info().

Variable Documentation

caller_save_needed

int caller_save_needed

extern

Flag set by local-alloc or global-alloc if they decide to allocate
something in a call-clobbered register.   

Flag set by local-alloc or global-alloc if anything is live in
a call-clobbered reg across calls.   

Referenced by allocno_reload_assign(), prepare_function_start(), reload(), and setup_reg_renumber().

default_target_regs

struct target_regs default_target_regs

extern

max_regno

int max_regno

extern

Maximum register number used in this function, plus one.   

Compute different info about registers.
   Copyright (C) 1987-2024 Free Software Foundation, Inc.

This file is part of GCC.

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

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

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

This file contains regscan pass of the compiler and passes for
dealing with info about modes of pseudo-registers inside
subregisters.  It also defines some tables of information about the
hardware registers, function init_reg_sets to initialize the
tables, and other auxiliary functions to deal with info about
registers and their classes.   

Maximum register number used in this function, plus one.   

Referenced by assign_by_spills(), build_insn_chain(), calculate_elim_costs_all_insns(), choose_reload_regs(), create_live_range_start_chains(), dead_or_predicable(), finish_spills(), fix_reg_equiv_init(), grow_reg_equivs(), if_convert(), init_eliminable_invariants(), init_live_reload_and_inheritance_pseudos(), init_lives(), init_loop_tree_node(), init_regno_assign_info(), ira(), ira_print_disposition(), ira_sort_regnos_for_alter_reg(), lra_assign(), lra_coalesce(), lra_create_live_ranges_1(), lra_final_code_change(), lra_need_for_scratch_reg_p(), lra_need_for_spills_p(), lra_remat(), lra_split_hard_reg_for(), print_live_ranges(), rebuild_regno_allocno_maps(), regstat_compute_calls_crossed(), regstat_compute_ri(), regstat_init_n_sets_and_refs(), reload(), reload_as_needed(), remove_init_insns(), remove_some_program_points_and_update_live_ranges(), run_rtl_passes(), setup_live_pseudos_and_spill_after_risky_transforms(), setup_preferred_alternate_classes_for_new_pseudos(), setup_reg_equiv_init(), spill_hard_reg(), and subst_reloads().

reg_info_p

struct reg_info_t* reg_info_p

extern

Referenced by regstat_compute_calls_crossed(), regstat_compute_ri(), regstat_free_calls_crossed(), and regstat_free_ri().

reg_info_p_size

size_t reg_info_p_size

extern

The number allocated elements of reg_info_p.   

Referenced by dump_reg_info(), regstat_compute_calls_crossed(), regstat_compute_ri(), regstat_free_calls_crossed(), and regstat_free_ri().

reg_renumber

short* reg_renumber

extern

Vector of substitutions of register numbers,
used to map pseudo regs into hardware regs.

This can't be folded into reg_n_info without changing all of the
machine dependent directories, since the reload functions
in the machine dependent files access it.   

Vector of substitutions of register numbers,
used to map pseudo regs into hardware regs.
This is set up as a result of register allocation.
Element N is the hard reg assigned to pseudo reg N,
or is -1 if no hard reg was assigned.
If N is a hard reg number, element N is N.   

Referenced by add_used_regs(), allocate_initial_values(), allocate_reg_info(), allocno_reload_assign(), alter_reg(), assign_by_spills(), assign_mem_slot(), build_insn_chain(), calculate_elim_costs_all_insns(), calculate_needs_all_insns(), calculate_spill_cost(), check_and_process_move(), compute_use_by_pseudos(), constrain_operands(), count_pseudo(), count_spilled_pseudo(), create_cands(), create_live_range_start_chains(), cselib_invalidate_regno(), curr_insn_transform(), delete_output_reload(), do_remat(), eliminate_regs_1(), elimination_effects(), emit_input_reload_insns(), find_reloads(), find_reloads_address_1(), find_reloads_toplev(), finish_spills(), free_reg_info(), get_hard_regs(), improve_inheritance(), inherit_in_ebb(), init_regno_assign_info(), ira_mark_allocation_change(), ira_reassign_pseudos(), ira_restore_scratches(), lra_assign(), lra_create_live_ranges_1(), lra_fp_pseudo_p(), lra_get_regno_hard_regno(), lra_setup_reg_renumber(), lra_split_hard_reg_for(), lra_undo_inheritance(), mark_home_live(), mark_home_live_1(), mark_referenced_regs(), mem_move_p(), move_unallocated_pseudos(), need_for_call_save_p(), need_for_split_p(), operand_to_remat(), prepare_function_start(), process_bb_lives(), pseudo_for_reload_consideration_p(), push_reload(), reg_overlap_for_remat_p(), regno_ok_for_base_p(), reload(), remove_init_insns(), resize_reg_info(), rtx_renumbered_equal_p(), save_call_clobbered_regs(), setup_live_pseudos_and_spill_after_risky_transforms(), setup_next_usage_insn(), setup_reg_renumber(), setup_save_areas(), spill_for(), spill_hard_reg(), spill_pseudos(), split_reg(), subst_indexed_address(), true_regnum(), undo_optional_reloads(), update_hard_regno_preference(), update_lives(), and will_delete_init_insn_p().

regstat_n_sets_and_refs

struct regstat_n_sets_and_refs_t* regstat_n_sets_and_refs

extern

Scanning of rtl for dataflow analysis.
   Copyright (C) 2007-2024 Free Software Foundation, Inc.
   Contributed by Kenneth Zadeck (zadeck@naturalbridge.com).

This file is part of GCC.

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

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

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

Referenced by dump_reg_info(), REG_N_REFS(), REG_N_SETS(), regstat_free_n_sets_and_refs(), and regstat_init_n_sets_and_refs().