GCC Middle and Back End API Reference
ira_allocno Struct Reference

#include <ira-int.h>

Collaboration diagram for ira_allocno:

Data Fields

int num
int regno
mode ENUM_BITFIELD(reg_class)
aclass unsigned int 
dont_reassign_p: 1
unsigned int no_stack_reg_p: 1
unsigned int total_no_stack_reg_p: 1
unsigned int bad_spill_p: 1
unsigned int assigned_p: 1
unsigned int conflict_vec_p: 1
short int hard_regno
ira_allocno_t next_regno_allocno
ira_loop_tree_node_t loop_tree_node
int nrefs
int freq
int class_cost
int updated_class_cost
int memory_cost
int updated_memory_cost
int excess_pressure_points_num
ira_pref_t allocno_prefs
ira_copy_t allocno_copies
ira_allocno_t cap
ira_allocno_t cap_member
int num_objects
ira_object_t objects [2]
int call_freq
int calls_crossed_num
int cheap_calls_crossed_num
int * hard_reg_costs
int * updated_hard_reg_costs
int * conflict_hard_reg_costs
int * updated_conflict_hard_reg_costs
void * add_data

Detailed Description

   A structure representing an allocno (allocation entity).  Allocno
   represents a pseudo-register in an allocation region.  If
   pseudo-register does not live in a region but it lives in the
   nested regions, it is represented in the region by special allocno
   called *cap*.  There may be more one cap representing the same
   pseudo-register in region.  It means that the corresponding
   pseudo-register lives in more one non-intersected subregion.  

Field Documentation

void* ira_allocno::add_data
     Different additional data.  It is used to decrease size of
     allocno data footprint.  
ira_copy_t ira_allocno::allocno_copies
     Copies to other non-conflicting allocnos.  The copies can
     represent move insn or potential move insn usually because of two
     operand insn constraints.  
ira_pref_t ira_allocno::allocno_prefs
     Allocno hard reg preferences.  
unsigned int ira_allocno::assigned_p
     TRUE if a hard register or memory has been assigned to the
unsigned int ira_allocno::bad_spill_p
     TRUE value means that there is no sense to spill the allocno
     during coloring because the spill will result in additional
     reloads in reload pass.  
int ira_allocno::call_freq
     Accumulated frequency of calls which given allocno
int ira_allocno::calls_crossed_num
     Accumulated number of the intersected calls.  
ira_allocno_t ira_allocno::cap
     It is a allocno (cap) representing given allocno on upper loop tree
ira_allocno_t ira_allocno::cap_member
     It is a link to allocno (cap) on lower loop level represented by
     given cap.  Null if given allocno is not a cap.  
int ira_allocno::cheap_calls_crossed_num
     The number of calls across which it is live, but which should not
     affect register preferences.  
int ira_allocno::class_cost
     Minimal accumulated and updated costs of usage register of the
     allocno class.  
int* ira_allocno::conflict_hard_reg_costs
     Array of decreasing costs (accumulated and the one updated during
     coloring) for allocnos conflicting with given allocno for hard
     regno of the allocno class.  The member value can be NULL if all
     costs are the same.  These costs are used to reflect preferences
     of other allocnos not assigned yet during assigning to given
unsigned int ira_allocno::conflict_vec_p
     TRUE if conflicts for given allocno are represented by vector of
     pointers to the conflicting allocnos.  Otherwise, we use a bit
     vector where a bit with given index represents allocno with the
     same number.  
ENUM_BITFIELD (machine_mode) mode ENUM_BITFIELD (reg_class) aclass unsigned int ira_allocno::dont_reassign_p
     Mode of the allocno which is the mode of the corresponding
     Register class which should be used for allocation for given
     allocno.  NO_REGS means that we should use memory.  
     During the reload, value TRUE means that we should not reassign a
     hard register to the allocno got memory earlier.  It is set up
     when we removed memory-memory move insn before each iteration of
     the reload.  
int ira_allocno::excess_pressure_points_num
     Accumulated number of points where the allocno lives and there is
     excess pressure for its class.  Excess pressure for a register
     class at some point means that there are more allocnos of given
     register class living at the point than number of hard-registers
     of the class available for the allocation.  
int ira_allocno::freq
     Accumulated frequency of usage of the allocno.  
int* ira_allocno::hard_reg_costs
     Array of usage costs (accumulated and the one updated during
     coloring) for each hard register of the allocno class.  The
     member value can be NULL if all costs are the same and equal to
     CLASS_COST.  For example, the costs of two different hard
     registers can be different if one hard register is callee-saved
     and another one is callee-used and the allocno lives through
     calls.  Another example can be case when for some insn the
     corresponding pseudo-register value should be put in specific
     register class (e.g. AREG for x86) which is a strict subset of
     the allocno class (GENERAL_REGS for x86).  We have updated costs
     to reflect the situation when the usage cost of a hard register
     is decreased because the allocno is connected to another allocno
     by a copy and the another allocno has been assigned to the hard
short int ira_allocno::hard_regno
     Hard register assigned to given allocno.  Negative value means
     that memory was allocated to the allocno.  During the reload,
     spilled allocno has value equal to the corresponding stack slot
     number (0, ...) - 2.  Value -1 is used for allocnos spilled by the
     reload (at this point pseudo-register has only one allocno) which
     did not get stack slot yet.  
ira_loop_tree_node_t ira_allocno::loop_tree_node
     There may be different allocnos with the same regno in different
     regions.  Allocnos are bound to the corresponding loop tree node.
     Pseudo-register may have only one regular allocno with given loop
     tree node but more than one cap (see comments above).  
int ira_allocno::memory_cost
     Minimal accumulated, and updated costs of memory for the allocno.
     At the allocation start, the original and updated costs are
     equal.  The updated cost may be changed after finishing
     allocation in a region and starting allocation in a subregion.
     The change reflects the cost of spill/restore code on the
     subregion border if we assign memory to the pseudo in the
ira_allocno_t ira_allocno::next_regno_allocno
     Allocnos with the same regno are linked by the following member.
     Allocnos corresponding to inner loops are first in the list (it
     corresponds to depth-first traverse of the loops).  
unsigned int ira_allocno::no_stack_reg_p
     Set to TRUE if allocno can't be assigned to the stack hard
     register correspondingly in this region and area including the
     region and all its subregions recursively.  
int ira_allocno::nrefs
     Accumulated usage references of the allocno.  Here and below,
     word 'accumulated' means info for given region and all nested
     subregions.  In this case, 'accumulated' means sum of references
     of the corresponding pseudo-register in this region and in all
     nested subregions recursively. 
int ira_allocno::num
     The allocno order number starting with 0.  Each allocno has an
     unique number and the number is never changed for the
int ira_allocno::num_objects
     The number of objects tracked in the following array.  
ira_object_t ira_allocno::objects[2]
     An array of structures describing conflict information and live
     ranges for each object associated with the allocno.  There may be
     more than one such object in cases where the allocno represents a
     multi-word register.  
int ira_allocno::regno
     Regno for allocno or cap.  
unsigned int ira_allocno::total_no_stack_reg_p
int ira_allocno::updated_class_cost
int * ira_allocno::updated_conflict_hard_reg_costs
int * ira_allocno::updated_hard_reg_costs
int ira_allocno::updated_memory_cost

The documentation for this struct was generated from the following file: