The following patch should solve problem
http://gcc.gnu.org/bugzilla/show_bug.cgi?id=48435. It might solve other
latest IRA problems too including performance related ones. The patch
is for targets which require some values to be placed in hard registers
starting with an even (odd) hard registers.
I already addressed an analogous problem recently and the patch I sent
that time although solved some problems it created even more new
problems. I should acknowledge this.
The problem was in that profitable hard regs were used for colorability
criterion and finding hard registers where allocno values can be resided
but *also* as starting allocno hard registers. It resulted in spilling
allocnos which should be placed in multi-registers starting on a
specific border because profitable hard registers were only starting
registers and when we calculated number of available hard registers
multi-register allocnos can not fit only in their starting hard registers.
The following patch was successfully bootstrapped on x86/x86-64 and on
i686 with H.J.'s autotester options.
OK to commit?
2011-04-07 Vladimir Makarov <vmaka...@redhat.com>
PR 4435
* ira-color.c (setup_profitable_hard_regs): Add comments.
Don't take prohibited hard regs into account.
(setup_conflict_profitable_regs): Rename to
get_conflict_profitable_regs.
(check_hard_reg_p): Check prohibited hard regs.
Index: ira-color.c
===================================================================
--- ira-color.c (revision 172107)
+++ ira-color.c (working copy)
@@ -1057,6 +1057,8 @@ setup_profitable_hard_regs (void)
enum reg_class aclass;
enum machine_mode mode;
+ /* Initial set up from allocno classes and explicitly conflicting
+ hard regs. */
EXECUTE_IF_SET_IN_BITMAP (coloring_allocno_bitmap, 0, i, bi)
{
a = ira_allocnos[i];
@@ -1076,9 +1078,6 @@ setup_profitable_hard_regs (void)
{
COPY_HARD_REG_SET (obj_data->profitable_hard_regs,
reg_class_contents[aclass]);
- AND_COMPL_HARD_REG_SET
- (obj_data->profitable_hard_regs,
- ira_prohibited_class_mode_regs[aclass][mode]);
AND_COMPL_HARD_REG_SET (obj_data->profitable_hard_regs,
ira_no_alloc_regs);
AND_COMPL_HARD_REG_SET (obj_data->profitable_hard_regs,
@@ -1086,6 +1085,7 @@ setup_profitable_hard_regs (void)
}
}
}
+ /* Exclude hard regs already assigned for conflicting objects. */
EXECUTE_IF_SET_IN_BITMAP (consideration_allocno_bitmap, 0, i, bi)
{
a = ira_allocnos[i];
@@ -1124,6 +1124,7 @@ setup_profitable_hard_regs (void)
}
}
}
+ /* Exclude too costly hard regs. */
EXECUTE_IF_SET_IN_BITMAP (coloring_allocno_bitmap, 0, i, bi)
{
int min_cost = INT_MAX;
@@ -1451,9 +1452,9 @@ update_conflict_hard_regno_costs (int *c
profitable regs exclude hard regs which can not hold value of mode
of allocno A. */
static inline void
-setup_conflict_profitable_regs (ira_allocno_t a, bool retry_p,
- HARD_REG_SET *conflict_regs,
- HARD_REG_SET *profitable_regs)
+get_conflict_profitable_regs (ira_allocno_t a, bool retry_p,
+ HARD_REG_SET *conflict_regs,
+ HARD_REG_SET *profitable_regs)
{
int i, nwords;
ira_object_t obj;
@@ -1485,8 +1486,15 @@ check_hard_reg_p (ira_allocno_t a, int h
HARD_REG_SET *conflict_regs, HARD_REG_SET *profitable_regs)
{
int j, nwords, nregs;
+ enum reg_class aclass;
+ enum machine_mode mode;
- nregs = hard_regno_nregs[hard_regno][ALLOCNO_MODE (a)];
+ aclass = ALLOCNO_CLASS (a);
+ mode = ALLOCNO_MODE (a);
+ if (TEST_HARD_REG_BIT (ira_prohibited_class_mode_regs[aclass][mode],
+ hard_regno))
+ return false;
+ nregs = hard_regno_nregs[hard_regno][mode];
nwords = ALLOCNO_NUM_OBJECTS (a);
for (j = 0; j < nregs; j++)
{
@@ -1554,8 +1562,8 @@ assign_hard_reg (ira_allocno_t a, bool r
#endif
ira_assert (! ALLOCNO_ASSIGNED_P (a));
- setup_conflict_profitable_regs (a, retry_p,
- conflicting_regs, profitable_hard_regs);
+ get_conflict_profitable_regs (a, retry_p,
+ conflicting_regs, profitable_hard_regs);
aclass = ALLOCNO_CLASS (a);
class_size = ira_class_hard_regs_num[aclass];
best_hard_regno = -1;
@@ -2233,7 +2241,8 @@ setup_allocno_available_regs_num (ira_al
ira_object_t obj = ALLOCNO_OBJECT (a, k);
object_color_data_t obj_data = OBJECT_COLOR_DATA (obj);
- /* Checking only profitable hard regs. */
+ /* Checking only profitable hard regs which exclude
+ object's conflict hard regs. */
if (TEST_HARD_REG_BIT (OBJECT_TOTAL_CONFLICT_HARD_REGS (obj),
hard_regno + j)
|| ! TEST_HARD_REG_BIT (obj_data->profitable_hard_regs,
@@ -2403,8 +2412,8 @@ improve_allocation (void)
else
base_cost = allocno_costs[ira_class_hard_reg_index[aclass][hregno]];
try_p = false;
- setup_conflict_profitable_regs (a, false,
- conflicting_regs, profitable_hard_regs);
+ get_conflict_profitable_regs (a, false,
+ conflicting_regs, profitable_hard_regs);
class_size = ira_class_hard_regs_num[aclass];
/* Set up cost improvement for usage of each profitable hard
register for allocno A. */
