}
/// Return the scaled distance from this index to the given one, where all
- /// slots on the same instruction have zero distance.
- int getInstrDistance(SlotIndex other) const {
+ /// slots on the same instruction have zero distance, assuming that the slot
+ /// indices are packed as densely as possible. There are normally gaps
+ /// between instructions, so this assumption often doesn't hold. This
+ /// results in this function often returning a value greater than the actual
+ /// instruction distance.
+ int getApproxInstrDistance(SlotIndex other) const {
return (other.listEntry()->getIndex() - listEntry()->getIndex())
/ Slot_Count;
}
// are singly defined, this produces optimal coloring in the absence of
// global interference and other constraints.
if (!ReverseLocalAssignment)
- Prio = LI.beginIndex().getInstrDistance(Indexes->getLastIndex());
+ Prio = LI.beginIndex().getApproxInstrDistance(Indexes->getLastIndex());
else {
// Allocating bottom up may allow many short LRGs to be assigned first
// to one of the cheap registers. This could be much faster for very
// large blocks on targets with many physical registers.
- Prio = Indexes->getZeroIndex().getInstrDistance(LI.endIndex());
+ Prio = Indexes->getZeroIndex().getApproxInstrDistance(LI.endIndex());
}
} else {
// Allocate global and split ranges in long->short order. Long ranges that