ira_allocno Struct Reference
#include <ira-int.h>
Collaboration diagram for ira_allocno:
Data Fields | |
| int | num |
| int | regno |
| ENUM_BITFIELD(machine_mode) 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
allocno.
| 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
intersects.
| 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
level.
| 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
allocno.
| 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
pseudo-register. 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
register.
| 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
subregion.
| 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
allocno.
| 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:
