GCC Middle and Back End API Reference
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)   mode_size[(int) GET_MODE (R)]
 
#define REGMODE_NATURAL_SIZE(MODE)   UNITS_PER_WORD
 
#define SET_REG_N_REFS(N, V)   (regstat_n_sets_and_refs[N].refs = V)
 
#define INC_REG_N_REFS(N, V)   (regstat_n_sets_and_refs[N].refs += V)
 
#define SET_REG_N_SETS(N, V)   (regstat_n_sets_and_refs[N].sets = V)
 
#define INC_REG_N_SETS(N, V)   (regstat_n_sets_and_refs[N].sets += V)
 
#define REG_FREQ(N)   (reg_info_p[N].freq)
 
#define REG_FREQ_MAX   1000
 
#define REG_FREQ_FROM_BB(bb)
 
#define REG_N_DEATHS(N)   (reg_info_p[N].deaths)
 
#define PSEUDO_REGNO_SIZE(N)
 
#define PSEUDO_REGNO_BYTES(N)    GET_MODE_SIZE (PSEUDO_REGNO_MODE (N))
 
#define PSEUDO_REGNO_MODE(N)   GET_MODE (regno_reg_rtx[N])
 
#define REG_N_CALLS_CROSSED(N)   (reg_info_p[N].calls_crossed)
 
#define REG_BLOCK_UNKNOWN   0
 
#define REG_BLOCK_GLOBAL   -1
 
#define REG_BASIC_BLOCK(N)   (reg_info_p[N].basic_block)
 
#define HARD_REGNO_CALLER_SAVE_MODE(REGNO, NREGS, MODE)    choose_hard_reg_mode (REGNO, NREGS, NULL)
 
#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_tregstat_n_sets_and_refs
 
struct reg_info_treg_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)

◆ direct_load

#define direct_load    (this_target_regs->x_direct_load)

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

◆ HARD_REGNO_CALLER_SAVE_MODE

#define HARD_REGNO_CALLER_SAVE_MODE ( REGNO,
NREGS,
MODE )    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)

◆ INC_REG_N_REFS

#define INC_REG_N_REFS ( N,
V )   (regstat_n_sets_and_refs[N].refs += V)

◆ INC_REG_N_SETS

#define INC_REG_N_SETS ( N,
V )   (regstat_n_sets_and_refs[N].sets += V)

Referenced by try_combine().

◆ PSEUDO_REGNO_BYTES

#define PSEUDO_REGNO_BYTES ( N)     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

◆ PSEUDO_REGNO_SIZE

#define PSEUDO_REGNO_SIZE ( N)
Value:
((GET_MODE_SIZE (PSEUDO_REGNO_MODE (N)) + UNITS_PER_WORD - 1) \
/ UNITS_PER_WORD)
#define N
Definition gensupport.cc:202
ALWAYS_INLINE poly_uint16 GET_MODE_SIZE(machine_mode mode)
Definition machmode.h:647
#define PSEUDO_REGNO_MODE(N)
Definition regs.h:161
Get the number of consecutive words required to hold pseudo-reg N.   

◆ REG_BASIC_BLOCK

◆ 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)    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)    (reg_info_p[N].freq)

◆ REG_FREQ_FROM_BB

#define REG_FREQ_FROM_BB ( bb)
Value:
|| !cfun->cfg->count_max.initialized_p ()) \
: ((bb)->count.to_frequency (cfun) \
? ((bb)->count.to_frequency (cfun) \
: 1)
#define BB_FREQ_MAX
Definition basic-block.h:158
static unsigned int count[debug_counter_number_of_counters]
Definition dbgcnt.cc:50
#define cfun
Definition function.h:475
optimize_size_level optimize_function_for_size_p(struct function *fun)
Definition predict.cc:265
#define REG_FREQ_MAX
Definition regs.h:125
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)    (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)    (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

◆ REGMODE_NATURAL_SIZE

#define REGMODE_NATURAL_SIZE ( MODE)    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 )   (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 )   (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)

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

◆ dump_reg_info()

◆ end_hard_regno()

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

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

◆ regstat_compute_calls_crossed()

void regstat_compute_calls_crossed ( void )
extern

◆ regstat_compute_ri()

void regstat_compute_ri ( void )
extern

◆ 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

◆ 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

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