[Top][All Lists]
[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[dotgnu-pnet-commits] libjit ./ChangeLog jit/jit-reg-alloc.c
|
From: |
Aleksey Demakov |
|
Subject: |
[dotgnu-pnet-commits] libjit ./ChangeLog jit/jit-reg-alloc.c |
|
Date: |
Thu, 25 May 2006 16:01:02 +0000 |
CVSROOT: /sources/dotgnu-pnet
Module name: libjit
Branch:
Changes by: Aleksey Demakov <address@hidden> 06/05/25 16:01:02
Modified files:
. : ChangeLog
jit : jit-reg-alloc.c
Log message:
fix spill cost calcualtion for global registers
CVSWeb URLs:
http://cvs.savannah.gnu.org/viewcvs/dotgnu-pnet/libjit/ChangeLog.diff?tr1=1.230&tr2=1.231&r1=text&r2=text
http://cvs.savannah.gnu.org/viewcvs/dotgnu-pnet/libjit/jit/jit-reg-alloc.c.diff?tr1=1.30&tr2=1.31&r1=text&r2=text
Patches:
Index: libjit/ChangeLog
diff -u libjit/ChangeLog:1.230 libjit/ChangeLog:1.231
--- libjit/ChangeLog:1.230 Wed May 24 18:56:32 2006
+++ libjit/ChangeLog Thu May 25 16:01:02 2006
@@ -1,6 +1,13 @@
2006-05-25 Aleksey Demakov <address@hidden>
* jit/jit-reg-alloc.c (use_cheapest_register): fix cost calculation
+ again for 'spill_before' rules. The last patch did not work for
+ values stored in global registers. Now both global and non-global
+ values should be copied to EAX.
+
+2006-05-25 Aleksey Demakov <address@hidden>
+
+ * jit/jit-reg-alloc.c (use_cheapest_register): fix cost calculation
that sometimes caused overlooking free registers. This was a serious
problem as there are some 'spill_before' rules that assume that the
allocator will always choose EAX as the first free register.
Index: libjit/jit/jit-reg-alloc.c
diff -u libjit/jit/jit-reg-alloc.c:1.30 libjit/jit/jit-reg-alloc.c:1.31
--- libjit/jit/jit-reg-alloc.c:1.30 Wed May 24 18:56:32 2006
+++ libjit/jit/jit-reg-alloc.c Thu May 25 16:01:02 2006
@@ -2391,7 +2391,7 @@
int suitable_reg;
int suitable_cost;
int suitable_age;
- int cost;
+ int move, cost;
if(index >= 0)
{
@@ -2426,94 +2426,131 @@
continue;
}
- if(need_pair)
- {
- other_reg = OTHER_REG(reg);
- }
- else
- {
- other_reg = -1;
- }
-
if(!jit_reg_is_used(regset, reg)
|| jit_reg_is_used(gen->inhibit, reg)
|| jit_reg_is_used(regs->assigned, reg))
{
continue;
}
- if(other_reg >= 0)
+
+ if(!desc)
{
- if(jit_reg_is_used(gen->inhibit, other_reg)
- || jit_reg_is_used(regs->assigned, other_reg))
+ if(jit_reg_is_used(gen->permanent, reg))
+ {
+ continue;
+ }
+ else if(thrashes_register(gen, regs, desc, reg, -1))
{
continue;
}
+ move = 0;
+ cost = compute_spill_cost(gen, regs, reg, -1);
}
-
- if(jit_reg_is_used(gen->permanent, reg))
+ else if(desc->value->has_global_register)
{
- /* We can use a global register only if it is the
register
- that contains the value itself and it is not
clobbered. */
- if(desc
- && desc->value->has_global_register
- && desc->value->global_reg == reg
- && !clobbers_register(gen, regs, index, reg,
other_reg))
+ if(reg == desc->value->global_reg)
{
- if(output || desc->value->in_global_register)
+ if(clobbers_register(gen, regs, index, reg, -1))
{
- cost = 0;
+ continue;
+ }
+ move = ((output |
desc->value->in_global_register) == 0);
+ cost = 0;
+ }
+ else if(jit_reg_is_used(gen->permanent, reg))
+ {
+ continue;
+ }
+ else if(thrashes_register(gen, regs, desc, reg, -1))
+ {
+ continue;
+ }
+ else if(desc->value->in_register && reg ==
desc->value->reg)
+ {
+ move = ((output |
desc->value->in_global_register) != 0);
+ if(clobbers_register(gen, regs, index, reg, -1))
+ {
+ cost = compute_spill_cost(gen, regs,
reg, -1);
}
else
{
- cost = 1;
+ cost = 0;
}
}
else
{
- cost = COST_TOO_MUCH;
+ move = 1;
+ cost = compute_spill_cost(gen, regs, reg, -1);
}
}
- else if(other_reg >= 0 && jit_reg_is_used(gen->permanent,
other_reg))
- {
- cost = COST_TOO_MUCH;
- }
- else if(thrashes_register(gen, regs, desc, reg, other_reg))
- {
- cost = COST_TOO_MUCH;
- }
- else if(desc && desc->value->in_register)
+ else
{
- if(reg == desc->value->reg)
+ if(jit_reg_is_used(gen->permanent, reg))
+ {
+ continue;
+ }
+
+ if(need_pair)
{
- if(clobbers_register(gen, regs, index, reg,
other_reg)
- && !(jit_reg_is_used(regs->clobber, reg)
- || (other_reg >= 0
- && jit_reg_is_used(regs->clobber,
other_reg))))
+ other_reg = OTHER_REG(reg);
+
+ if(jit_reg_is_used(gen->inhibit, other_reg)
+ || jit_reg_is_used(regs->assigned,
other_reg))
{
- cost = compute_spill_cost(gen, regs,
reg, other_reg);
+ continue;
+ }
+ if(jit_reg_is_used(gen->permanent, other_reg))
+ {
+ continue;
+ }
+ }
+ else
+ {
+ other_reg = -1;
+ }
+
+ if(thrashes_register(gen, regs, desc, reg, other_reg))
+ {
+ continue;
+ }
+ if(desc->value->in_register)
+ {
+ if(reg == desc->value->reg)
+ {
+ if(clobbers_register(gen, regs, index,
reg, other_reg)
+ && !(jit_reg_is_used(regs->clobber,
reg)
+ || (other_reg >= 0
+ &&
jit_reg_is_used(regs->clobber, other_reg))))
+ {
+ move = 0;
+ cost = compute_spill_cost(gen,
regs, reg, other_reg);
+ }
+ else
+ {
+ move = 0;
+ cost = 0;
+ }
}
else
{
- cost = 0;
+ move = 1;
+ cost = compute_spill_cost(gen, regs,
reg, other_reg);
}
}
else
{
- cost = 1 + compute_spill_cost(gen, regs, reg,
other_reg);
+ move = 0;
+ cost = compute_spill_cost(gen, regs, reg,
other_reg);
}
}
- else
- {
- cost = compute_spill_cost(gen, regs, reg, other_reg);
- }
- if(cost < suitable_cost
- || (cost > 0 && cost == suitable_cost
+ if((move + cost) < suitable_cost
+ || (cost > 0 && (move + cost) == suitable_cost
&& gen->contents[reg].age < suitable_age))
{
/* This is the oldest suitable register of this type */
suitable_reg = reg;
- suitable_cost = cost;
+ suitable_cost = move + cost;
suitable_age = gen->contents[reg].age;
}
}