maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

Refactor LiveInterval: introduce new LiveRange class 

LiveRange just manages a list of segments and a list of value numbers
now as LiveInterval did previously, but without having details like spill
weight or a fixed register number.
LiveInterval is now a subclass of LiveRange and simply adds the spill weight
and the register number.

llvm-svn: 192393
This commit is contained in:
Matthias Braun 2013-10-10 21:28:47 +00:00
parent 13ddb7cd65
commit d7df935bbc
4 changed files with 235 additions and 217 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

219
llvm/include/llvm/CodeGen/LiveInterval.h
View File

@ -7,14 +7,14 @@
//
//===----------------------------------------------------------------------===//
//
// This file implements the LiveInterval class. Given some numbering of each
// the machine instructions an interval [i, j) is said to be a
// live interval for register v if there is no instruction with number j' >= j
// This file implements the LiveRange and LiveInterval classes. Given some
// numbering of each the machine instructions an interval [i, j) is said to be a
// live range for register v if there is no instruction with number j' >= j
// such that v is live at j' and there is no instruction with number i' < i such
// that v is live at i'. In this implementation intervals can have holes,
// i.e. an interval might look like [1,20), [50,65), [1000,1001). Each
// individual segment is represented as an instance of LiveInterval::Segment,
// and the whole range is represented as an instance of LiveInterval.
// that v is live at i'. In this implementation ranges can have holes,
// i.e. a range might look like [1,20), [50,65), [1000,1001). Each
// individual segment is represented as an instance of LiveRange::Segment,
// and the whole range is represented as an instance of LiveRange.
//
//===----------------------------------------------------------------------===//
@ -35,6 +35,7 @@ namespace llvm {
class MachineRegisterInfo;
class TargetRegisterInfo;
class raw_ostream;
template <typename T, unsigned Small> class SmallPtrSet;
/// VNInfo - Value Number Information.
/// This class holds information about a machine level values, including
@ -78,10 +79,12 @@ namespace llvm {
void markUnused() { def = SlotIndex(); }
};
/// LiveInterval - This class represents some number of live segments for a
/// register or value. This class also contains a bit of register allocator
/// state.
class LiveInterval {
/// This class represents the liveness of a register, stack slot, etc.
/// It manages an ordered list of Segment objects.
/// The Segments are organized in a static single assignment form: At places
/// where a new value is defined or different values reach a CFG join a new
/// segment with a new value number is used.
class LiveRange {
public:
/// This represents a simple continuous liveness interval for a value.
@ -123,14 +126,9 @@ namespace llvm {
typedef SmallVector<Segment,4> Segments;
typedef SmallVector<VNInfo*,4> VNInfoList;
const unsigned reg; // the register or stack slot of this interval.
float weight; // weight of this interval
Segments segments; // the segments in which this register is live
Segments segments; // the liveness segments
VNInfoList valnos; // value#'s
LiveInterval(unsigned Reg, float Weight)
: reg(Reg), weight(Weight) {}
typedef Segments::iterator iterator;
iterator begin() { return segments.begin(); }
iterator end() { return segments.end(); }
@ -141,15 +139,15 @@ namespace llvm {
typedef VNInfoList::iterator vni_iterator;
vni_iterator vni_begin() { return valnos.begin(); }
vni_iterator vni_end() { return valnos.end(); }
vni_iterator vni_end() { return valnos.end(); }
typedef VNInfoList::const_iterator const_vni_iterator;
const_vni_iterator vni_begin() const { return valnos.begin(); }
const_vni_iterator vni_end() const { return valnos.end(); }
const_vni_iterator vni_end() const { return valnos.end(); }
/// advanceTo - Advance the specified iterator to point to the Segment
/// containing the specified position, or end() if the position is past the
/// end of the interval. If no Segment contains this position, but the
/// end of the range. If no Segment contains this position, but the
/// position is in a hole, this method returns an iterator pointing to the
/// Segment immediately after the hole.
iterator advanceTo(iterator I, SlotIndex Pos) {
@ -162,7 +160,7 @@ namespace llvm {
/// find - Return an iterator pointing to the first segment that ends after
/// Pos, or end(). This is the same as advanceTo(begin(), Pos), but faster
/// when searching large intervals.
/// when searching large ranges.
///
/// If Pos is contained in a Segment, that segment is returned.
/// If Pos is in a hole, the following Segment is returned.
@ -170,7 +168,7 @@ namespace llvm {
iterator find(SlotIndex Pos);
const_iterator find(SlotIndex Pos) const {
return const_cast<LiveInterval*>(this)->find(Pos);
return const_cast<LiveRange*>(this)->find(Pos);
}
void clear() {
@ -197,7 +195,7 @@ namespace llvm {
return valnos[ValNo];
}
/// containsValue - Returns true if VNI belongs to this interval.
/// containsValue - Returns true if VNI belongs to this range.
bool containsValue(const VNInfo *VNI) const {
return VNI && VNI->id < getNumValNums() && VNI == getValNumInfo(VNI->id);
}
@ -211,7 +209,7 @@ namespace llvm {
return VNI;
}
/// createDeadDef - Make sure the interval has a value defined at Def.
/// createDeadDef - Make sure the range has a value defined at Def.
/// If one already exists, return it. Otherwise allocate a new value and
/// add liveness for a dead def.
VNInfo *createDeadDef(SlotIndex Def, VNInfo::Allocator &VNInfoAllocator);
@ -237,32 +235,32 @@ namespace llvm {
VNInfo* MergeValueNumberInto(VNInfo *V1, VNInfo *V2);
/// Merge all of the live segments of a specific val# in RHS into this live
/// interval as the specified value number. The segments in RHS are allowed
/// to overlap with segments in the current interval, it will replace the
/// range as the specified value number. The segments in RHS are allowed
/// to overlap with segments in the current range, it will replace the
/// value numbers of the overlaped live segments with the specified value
/// number.
void MergeSegmentsInAsValue(const LiveInterval &RHS, VNInfo *LHSValNo);
void MergeSegmentsInAsValue(const LiveRange &RHS, VNInfo *LHSValNo);
/// MergeValueInAsValue - Merge all of the segments of a specific val#
/// in RHS into this live interval as the specified value number.
/// in RHS into this live range as the specified value number.
/// The segments in RHS are allowed to overlap with segments in the
/// current interval, but only if the overlapping segments have the
/// current range, but only if the overlapping segments have the
/// specified value number.
void MergeValueInAsValue(const LiveInterval &RHS,
void MergeValueInAsValue(const LiveRange &RHS,
const VNInfo *RHSValNo, VNInfo *LHSValNo);
bool empty() const { return segments.empty(); }
/// beginIndex - Return the lowest numbered slot covered by interval.
/// beginIndex - Return the lowest numbered slot covered.
SlotIndex beginIndex() const {
assert(!empty() && "Call to beginIndex() on empty interval.");
assert(!empty() && "Call to beginIndex() on empty range.");
return segments.front().start;
}
/// endNumber - return the maximum point of the interval of the whole,
/// endNumber - return the maximum point of the range of the whole,
/// exclusive.
SlotIndex endIndex() const {
assert(!empty() && "Call to endIndex() on empty interval.");
assert(!empty() && "Call to endIndex() on empty range.");
return segments.back().end;
}
@ -315,47 +313,47 @@ namespace llvm {
return I != end() && I->start <= Idx ? I : end();
}
/// overlaps - Return true if the intersection of the two live intervals is
/// overlaps - Return true if the intersection of the two live ranges is
/// not empty.
bool overlaps(const LiveInterval& other) const {
bool overlaps(const LiveRange &other) const {
if (other.empty())
return false;
return overlapsFrom(other, other.begin());
}
/// overlaps - Return true if the two intervals have overlapping segments
/// overlaps - Return true if the two ranges have overlapping segments
/// that are not coalescable according to CP.
///
/// Overlapping segments where one interval is defined by a coalescable
/// Overlapping segments where one range is defined by a coalescable
/// copy are allowed.
bool overlaps(const LiveInterval &Other, const CoalescerPair &CP,
bool overlaps(const LiveRange &Other, const CoalescerPair &CP,
const SlotIndexes&) const;
/// overlaps - Return true if the live interval overlaps an interval
/// specified by [Start, End).
/// overlaps - Return true if the live range overlaps an interval specified
/// by [Start, End).
bool overlaps(SlotIndex Start, SlotIndex End) const;
/// overlapsFrom - Return true if the intersection of the two live intervals
/// overlapsFrom - Return true if the intersection of the two live ranges
/// is not empty. The specified iterator is a hint that we can begin
/// scanning the Other interval starting at I.
bool overlapsFrom(const LiveInterval& other, const_iterator I) const;
/// scanning the Other range starting at I.
bool overlapsFrom(const LiveRange &Other, const_iterator I) const;
/// Add the specified Segment to this interval, merging segments as
/// Add the specified Segment to this range, merging segments as
/// appropriate. This returns an iterator to the inserted segment (which
/// may have grown since it was inserted).
iterator addSegment(Segment S) {
return addSegmentFrom(S, segments.begin());
}
/// extendInBlock - If this interval is live before Kill in the basic block
/// extendInBlock - If this range is live before Kill in the basic block
/// that starts at StartIdx, extend it to be live up to Kill, and return
/// the value. If there is no segment before Kill, return NULL.
VNInfo *extendInBlock(SlotIndex StartIdx, SlotIndex Kill);
/// join - Join two live intervals (this, and other) together. This applies
/// mappings to the value numbers in the LHS/RHS intervals as specified. If
/// the intervals are not joinable, this aborts.
void join(LiveInterval &Other,
/// join - Join two live ranges (this, and other) together. This applies
/// mappings to the value numbers in the LHS/RHS ranges as specified. If
/// the ranges are not joinable, this aborts.
void join(LiveRange &Other,
const int *ValNoAssignments,
const int *RHSValNoAssignments,
SmallVectorImpl<VNInfo *> &NewVNInfo);
@ -369,7 +367,7 @@ namespace llvm {
endIndex() < End.getBoundaryIndex();
}
/// Remove the specified segment from this interval. Note that the segment
/// Remove the specified segment from this range. Note that the segment
/// must be a single Segment in its entirety.
void removeSegment(SlotIndex Start, SlotIndex End,
bool RemoveDeadValNo = false);
@ -382,12 +380,8 @@ namespace llvm {
/// Also remove the value# from value# list.
void removeValNo(VNInfo *ValNo);
/// getSize - Returns the sum of sizes of all the Segment's.
///
unsigned getSize() const;
/// Returns true if the live interval is zero length, i.e. no segments
/// span instructions. It doesn't pay to spill such an interval.
/// Returns true if the live range is zero length, i.e. no live segments
/// span instructions. It doesn't pay to spill such a range.
bool isZeroLength(SlotIndexes *Indexes) const {
for (const_iterator i = begin(), e = end(); i != e; ++i)
if (Indexes->getNextNonNullIndex(i->start).getBaseIndex() <
@ -396,27 +390,16 @@ namespace llvm {
return true;
}
/// isSpillable - Can this interval be spilled?
bool isSpillable() const {
return weight != HUGE_VALF;
}
/// markNotSpillable - Mark interval as not spillable
void markNotSpillable() {
weight = HUGE_VALF;
}
bool operator<(const LiveInterval& other) const {
bool operator<(const LiveRange& other) const {
const SlotIndex &thisIndex = beginIndex();
const SlotIndex &otherIndex = other.beginIndex();
return (thisIndex < otherIndex ||
(thisIndex == otherIndex && reg < other.reg));
return thisIndex < otherIndex;
}
void print(raw_ostream &OS) const;
void dump() const;
/// \brief Walk the interval and assert if any invariants fail to hold.
/// \brief Walk the range and assert if any invariants fail to hold.
///
/// Note that this is a no-op when asserts are disabled.
#ifdef NDEBUG
@ -432,6 +415,45 @@ namespace llvm {
iterator extendSegmentStartTo(iterator I, SlotIndex NewStr);
void markValNoForDeletion(VNInfo *V);
};
inline raw_ostream &operator<<(raw_ostream &OS, const LiveRange &LR) {
LR.print(OS);
return OS;
}
/// LiveInterval - This class represents the liveness of a register,
/// or stack slot.
class LiveInterval : public LiveRange {
public:
const unsigned reg; // the register or stack slot of this interval.
float weight; // weight of this interval
LiveInterval(unsigned Reg, float Weight)
: reg(Reg), weight(Weight) {}
/// getSize - Returns the sum of sizes of all the LiveRange's.
///
unsigned getSize() const;
/// isSpillable - Can this interval be spilled?
bool isSpillable() const {
return weight != HUGE_VALF;
}
/// markNotSpillable - Mark interval as not spillable
void markNotSpillable() {
weight = HUGE_VALF;
}
bool operator<(const LiveInterval& other) const {
const SlotIndex &thisIndex = beginIndex();
const SlotIndex &otherIndex = other.beginIndex();
return thisIndex < otherIndex ||
(thisIndex == otherIndex && reg < other.reg);
}
private:
LiveInterval& operator=(const LiveInterval& rhs) LLVM_DELETED_FUNCTION;
};
@ -441,65 +463,65 @@ namespace llvm {
return OS;
}
raw_ostream &operator<<(raw_ostream &OS, const LiveInterval::Segment &S);
raw_ostream &operator<<(raw_ostream &OS, const LiveRange::Segment &S);
inline bool operator<(SlotIndex V, const LiveInterval::Segment &S) {
inline bool operator<(SlotIndex V, const LiveRange::Segment &S) {
return V < S.start;
}
inline bool operator<(const LiveInterval::Segment &S, SlotIndex V) {
inline bool operator<(const LiveRange::Segment &S, SlotIndex V) {
return S.start < V;
}
/// Helper class for performant LiveInterval bulk updates.
/// Helper class for performant LiveRange bulk updates.
///
/// Calling LiveInterval::addSegment() repeatedly can be expensive on large
/// Calling LiveRange::addSegment() repeatedly can be expensive on large
/// live ranges because segments after the insertion point may need to be
/// shifted. The LiveRangeUpdater class can defer the shifting when adding
/// many segments in order.
///
/// The LiveInterval will be in an invalid state until flush() is called.
/// The LiveRange will be in an invalid state until flush() is called.
class LiveRangeUpdater {
LiveInterval *LI;
LiveRange *LR;
SlotIndex LastStart;
LiveInterval::iterator WriteI;
LiveInterval::iterator ReadI;
SmallVector<LiveInterval::Segment, 16> Spills;
LiveRange::iterator WriteI;
LiveRange::iterator ReadI;
SmallVector<LiveRange::Segment, 16> Spills;
void mergeSpills();
public:
/// Create a LiveRangeUpdater for adding segments to LI.
/// LI will temporarily be in an invalid state until flush() is called.
LiveRangeUpdater(LiveInterval *li = 0) : LI(li) {}
/// Create a LiveRangeUpdater for adding segments to LR.
/// LR will temporarily be in an invalid state until flush() is called.
LiveRangeUpdater(LiveRange *lr = 0) : LR(lr) {}
~LiveRangeUpdater() { flush(); }
/// Add a segment to LI and coalesce when possible, just like
/// LI.addSegment(). Segments should be added in increasing start order for
/// Add a segment to LR and coalesce when possible, just like
/// LR.addSegment(). Segments should be added in increasing start order for
/// best performance.
void add(LiveInterval::Segment);
void add(LiveRange::Segment);
void add(SlotIndex Start, SlotIndex End, VNInfo *VNI) {
add(LiveInterval::Segment(Start, End, VNI));
add(LiveRange::Segment(Start, End, VNI));
}
/// Return true if the LI is currently in an invalid state, and flush()
/// Return true if the LR is currently in an invalid state, and flush()
/// needs to be called.
bool isDirty() const { return LastStart.isValid(); }
/// Flush the updater state to LI so it is valid and contains all added
/// Flush the updater state to LR so it is valid and contains all added
/// segments.
void flush();
/// Select a different destination live range.
void setDest(LiveInterval *li) {
if (LI != li && isDirty())
void setDest(LiveRange *lr) {
if (LR != lr && isDirty())
flush();
LI = li;
LR = lr;
}
/// Get the current destination live range.
LiveInterval *getDest() const { return LI; }
LiveRange *getDest() const { return LR; }
void dump() const;
void print(raw_ostream&) const;
@ -521,15 +543,18 @@ namespace llvm {
SlotIndex EndPoint;
bool Kill;
void init(const LiveRange &LR, SlotIndex Idx) {
}
public:
/// Create a LiveRangeQuery for the given live range and instruction index.
/// The sub-instruction slot of Idx doesn't matter, only the instruction it
/// refers to is considered.
LiveRangeQuery(const LiveInterval &LI, SlotIndex Idx)
LiveRangeQuery(const LiveRange &LR, SlotIndex Idx)
: EarlyVal(0), LateVal(0), Kill(false) {
// Find the segment that enters the instruction.
LiveInterval::const_iterator I = LI.find(Idx.getBaseIndex());
LiveInterval::const_iterator E = LI.end();
LiveRange::const_iterator I = LR.find(Idx.getBaseIndex());
LiveRange::const_iterator E = LR.end();
if (I == E)
return;
// Is this an instruction live-in segment?

8
llvm/include/llvm/CodeGen/LiveIntervalAnalysis.h
View File

@ -206,14 +206,14 @@ namespace llvm {
return Indexes->getMBBEndIdx(mbb);
}
bool isLiveInToMBB(const LiveInterval &li,
bool isLiveInToMBB(const LiveRange &LR,
const MachineBasicBlock *mbb) const {
return li.liveAt(getMBBStartIdx(mbb));
return LR.liveAt(getMBBStartIdx(mbb));
}
bool isLiveOutOfMBB(const LiveInterval &li,
bool isLiveOutOfMBB(const LiveRange &LR,
const MachineBasicBlock *mbb) const {
return li.liveAt(getMBBEndIdx(mbb).getPrevSlot());
return LR.liveAt(getMBBEndIdx(mbb).getPrevSlot());
}
MachineBasicBlock* getMBBFromIndex(SlotIndex index) const {

190
llvm/lib/CodeGen/LiveInterval.cpp
View File

@ -7,14 +7,14 @@
//
//===----------------------------------------------------------------------===//
//
// This file implements the LiveInterval class. Given some
// This file implements the LiveRange and LiveInterval classes. Given some
// numbering of each the machine instructions an interval [i, j) is said to be a
// live interval for register v if there is no instruction with number j' > j
// live range for register v if there is no instruction with number j' >= j
// such that v is live at j' and there is no instruction with number i' < i such
// that v is live at i'. In this implementation intervals can have holes,
// i.e. an interval might look like [1,20), [50,65), [1000,1001). Each
// individual segment is represented as an instance of Segment, and the whole
// range is represented as an instance of LiveInterval.
// that v is live at i'. In this implementation ranges can have holes,
// i.e. a range might look like [1,20), [50,65), [1000,1001). Each
// individual segment is represented as an instance of LiveRange::Segment,
// and the whole range is represented as an instance of LiveRange.
//
//===----------------------------------------------------------------------===//
@ -31,7 +31,7 @@
#include <algorithm>
using namespace llvm;
LiveInterval::iterator LiveInterval::find(SlotIndex Pos) {
LiveRange::iterator LiveRange::find(SlotIndex Pos) {
// This algorithm is basically std::upper_bound.
// Unfortunately, std::upper_bound cannot be used with mixed types until we
// adopt C++0x. Many libraries can do it, but not all.
@ -49,8 +49,8 @@ LiveInterval::iterator LiveInterval::find(SlotIndex Pos) {
return I;
}
VNInfo *LiveInterval::createDeadDef(SlotIndex Def,
VNInfo::Allocator &VNInfoAllocator) {
VNInfo *LiveRange::createDeadDef(SlotIndex Def,
VNInfo::Allocator &VNInfoAllocator) {
assert(!Def.isDead() && "Cannot define a value at the dead slot");
iterator I = find(Def);
if (I == end()) {
@ -77,7 +77,7 @@ VNInfo *LiveInterval::createDeadDef(SlotIndex Def,
return VNI;
}
// overlaps - Return true if the intersection of the two live intervals is
// overlaps - Return true if the intersection of the two live ranges is
// not empty.
//
// An example for overlaps():
@ -86,7 +86,7 @@ VNInfo *LiveInterval::createDeadDef(SlotIndex Def,
// 4: B = ...
// 8: C = A + B ;; last use of A
//
// The live intervals should look like:
// The live ranges should look like:
//
// A = [3, 11)
// B = [7, x)
@ -95,9 +95,9 @@ VNInfo *LiveInterval::createDeadDef(SlotIndex Def,
// A->overlaps(C) should return false since we want to be able to join
// A and C.
//
bool LiveInterval::overlapsFrom(const LiveInterval& other,
const_iterator StartPos) const {
assert(!empty() && "empty interval");
bool LiveRange::overlapsFrom(const LiveRange& other,
const_iterator StartPos) const {
assert(!empty() && "empty range");
const_iterator i = begin();
const_iterator ie = end();
const_iterator j = StartPos;
@ -136,10 +136,9 @@ bool LiveInterval::overlapsFrom(const LiveInterval& other,
return false;
}
bool LiveInterval::overlaps(const LiveInterval &Other,
const CoalescerPair &CP,
const SlotIndexes &Indexes) const {
assert(!empty() && "empty interval");
bool LiveRange::overlaps(const LiveRange &Other, const CoalescerPair &CP,
const SlotIndexes &Indexes) const {
assert(!empty() && "empty range");
if (Other.empty())
return false;
@ -178,9 +177,9 @@ bool LiveInterval::overlaps(const LiveInterval &Other,
}
}
/// overlaps - Return true if the live interval overlaps a segment specified
/// overlaps - Return true if the live range overlaps an interval specified
/// by [Start, End).
bool LiveInterval::overlaps(SlotIndex Start, SlotIndex End) const {
bool LiveRange::overlaps(SlotIndex Start, SlotIndex End) const {
assert(Start < End && "Invalid range");
const_iterator I = std::lower_bound(begin(), end(), End);
return I != begin() && (--I)->end > Start;
@ -190,7 +189,7 @@ bool LiveInterval::overlaps(SlotIndex Start, SlotIndex End) const {
/// ValNo is dead, remove it. If it is the largest value number, just nuke it
/// (and any other deleted values neighboring it), otherwise mark it as ~1U so
/// it can be nuked later.
void LiveInterval::markValNoForDeletion(VNInfo *ValNo) {
void LiveRange::markValNoForDeletion(VNInfo *ValNo) {
if (ValNo->id == getNumValNums()-1) {
do {
valnos.pop_back();
@ -202,7 +201,7 @@ void LiveInterval::markValNoForDeletion(VNInfo *ValNo) {
/// RenumberValues - Renumber all values in order of appearance and delete the
/// remaining unused values.
void LiveInterval::RenumberValues() {
void LiveRange::RenumberValues() {
SmallPtrSet<VNInfo*, 8> Seen;
valnos.clear();
for (const_iterator I = begin(), E = end(); I != E; ++I) {
@ -218,7 +217,7 @@ void LiveInterval::RenumberValues() {
/// This method is used when we want to extend the segment specified by I to end
/// at the specified endpoint. To do this, we should merge and eliminate all
/// segments that this will overlap with. The iterator is not invalidated.
void LiveInterval::extendSegmentEndTo(iterator I, SlotIndex NewEnd) {
void LiveRange::extendSegmentEndTo(iterator I, SlotIndex NewEnd) {
assert(I != end() && "Not a valid segment!");
VNInfo *ValNo = I->valno;
@ -228,7 +227,7 @@ void LiveInterval::extendSegmentEndTo(iterator I, SlotIndex NewEnd) {
assert(MergeTo->valno == ValNo && "Cannot merge with differing values!");
}
// If NewEnd was in the middle of an segment, make sure to get its endpoint.
// If NewEnd was in the middle of a segment, make sure to get its endpoint.
I->end = std::max(NewEnd, prior(MergeTo)->end);
// If the newly formed segment now touches the segment after it and if they
@ -247,8 +246,8 @@ void LiveInterval::extendSegmentEndTo(iterator I, SlotIndex NewEnd) {
/// This method is used when we want to extend the segment specified by I to
/// start at the specified endpoint. To do this, we should merge and eliminate
/// all segments that this will overlap with.
LiveInterval::iterator
LiveInterval::extendSegmentStartTo(iterator I, SlotIndex NewStart) {
LiveRange::iterator
LiveRange::extendSegmentStartTo(iterator I, SlotIndex NewStart) {
assert(I != end() && "Not a valid segment!");
VNInfo *ValNo = I->valno;
@ -279,8 +278,7 @@ LiveInterval::extendSegmentStartTo(iterator I, SlotIndex NewStart) {
return MergeTo;
}
LiveInterval::iterator
LiveInterval::addSegmentFrom(Segment S, iterator From) {
LiveRange::iterator LiveRange::addSegmentFrom(Segment S, iterator From) {
SlotIndex Start = S.start, End = S.end;
iterator it = std::upper_bound(From, end(), Start);
@ -328,10 +326,10 @@ LiveInterval::addSegmentFrom(Segment S, iterator From) {
return segments.insert(it, S);
}
/// extendInBlock - If this interval is live before Kill in the basic
/// extendInBlock - If this range is live before Kill in the basic
/// block that starts at StartIdx, extend it to be live up to Kill and return
/// the value. If there is no segment before Kill, return NULL.
VNInfo *LiveInterval::extendInBlock(SlotIndex StartIdx, SlotIndex Kill) {
/// the value. If there is no live range before Kill, return NULL.
VNInfo *LiveRange::extendInBlock(SlotIndex StartIdx, SlotIndex Kill) {
if (empty())
return 0;
iterator I = std::upper_bound(begin(), end(), Kill.getPrevSlot());
@ -345,15 +343,15 @@ VNInfo *LiveInterval::extendInBlock(SlotIndex StartIdx, SlotIndex Kill) {
return I->valno;
}
/// Remove the specified segment from this interval. Note that the segment must
/// Remove the specified segment from this range. Note that the segment must
/// be in a single Segment in its entirety.
void LiveInterval::removeSegment(SlotIndex Start, SlotIndex End,
bool RemoveDeadValNo) {
void LiveRange::removeSegment(SlotIndex Start, SlotIndex End,
bool RemoveDeadValNo) {
// Find the Segment containing this span.
iterator I = find(Start);
assert(I != end() && "Segment is not in interval!");
assert(I != end() && "Segment is not in range!");
assert(I->containsInterval(Start, End)
&& "Segment is not entirely in interval!");
&& "Segment is not entirely in range!");
// If the span we are removing is at the start of the Segment, adjust it.
VNInfo *ValNo = I->valno;
@ -388,7 +386,7 @@ void LiveInterval::removeSegment(SlotIndex Start, SlotIndex End,
// Otherwise, we are splitting the Segment into two pieces.
SlotIndex OldEnd = I->end;
I->end = Start; // Trim the old interval.
I->end = Start; // Trim the old segment.
// Insert the new one.
segments.insert(llvm::next(I), Segment(End, OldEnd, ValNo));
@ -396,7 +394,7 @@ void LiveInterval::removeSegment(SlotIndex Start, SlotIndex End,
/// removeValNo - Remove all the segments defined by the specified value#.
/// Also remove the value# from value# list.
void LiveInterval::removeValNo(VNInfo *ValNo) {
void LiveRange::removeValNo(VNInfo *ValNo) {
if (empty()) return;
iterator I = end();
iterator E = begin();
@ -409,17 +407,14 @@ void LiveInterval::removeValNo(VNInfo *ValNo) {
markValNoForDeletion(ValNo);
}
/// join - Join two live intervals (this, and other) together. This applies
/// mappings to the value numbers in the LHS/RHS intervals as specified. If
/// the intervals are not joinable, this aborts.
void LiveInterval::join(LiveInterval &Other,
const int *LHSValNoAssignments,
const int *RHSValNoAssignments,
SmallVectorImpl<VNInfo *> &NewVNInfo) {
void LiveRange::join(LiveRange &Other,
const int *LHSValNoAssignments,
const int *RHSValNoAssignments,
SmallVectorImpl<VNInfo *> &NewVNInfo) {
verify();
// Determine if any of our values are mapped. This is uncommon, so we want
// to avoid the interval scan if not.
// to avoid the range scan if not.
bool MustMapCurValNos = false;
unsigned NumVals = getNumValNums();
unsigned NumNewVals = NewVNInfo.size();
@ -432,8 +427,7 @@ void LiveInterval::join(LiveInterval &Other,
}
}
// If we have to apply a mapping to our base interval assignment, rewrite it
// now.
// If we have to apply a mapping to our base range assignment, rewrite it now.
if (MustMapCurValNos && !empty()) {
// Map the first live range.
@ -449,7 +443,7 @@ void LiveInterval::join(LiveInterval &Other,
if (OutIt->valno == nextValNo && OutIt->end == I->start) {
OutIt->end = I->end;
} else {
// Didn't merge. Move OutIt to the next interval,
// Didn't merge. Move OutIt to the next segment,
++OutIt;
OutIt->valno = nextValNo;
if (OutIt != I) {
@ -471,7 +465,7 @@ void LiveInterval::join(LiveInterval &Other,
I->valno = NewVNInfo[RHSValNoAssignments[I->valno->id]];
// Update val# info. Renumber them and make sure they all belong to this
// LiveInterval now. Also remove dead val#'s.
// LiveRange now. Also remove dead val#'s.
unsigned NumValNos = 0;
for (unsigned i = 0; i < NumNewVals; ++i) {
VNInfo *VNI = NewVNInfo[i];
@ -492,25 +486,25 @@ void LiveInterval::join(LiveInterval &Other,
Updater.add(*I);
}
/// Merge all of the segments in RHS into this live interval as the specified
/// Merge all of the segments in RHS into this live range as the specified
/// value number. The segments in RHS are allowed to overlap with segments in
/// the current interval, but only if the overlapping segments have the
/// the current range, but only if the overlapping segments have the
/// specified value number.
void LiveInterval::MergeSegmentsInAsValue(const LiveInterval &RHS,
VNInfo *LHSValNo) {
void LiveRange::MergeSegmentsInAsValue(const LiveRange &RHS,
VNInfo *LHSValNo) {
LiveRangeUpdater Updater(this);
for (const_iterator I = RHS.begin(), E = RHS.end(); I != E; ++I)
Updater.add(I->start, I->end, LHSValNo);
}
/// MergeValueInAsValue - Merge all of the live segments of a specific val#
/// in RHS into this live interval as the specified value number.
/// in RHS into this live range as the specified value number.
/// The segments in RHS are allowed to overlap with segments in the
/// current interval, it will replace the value numbers of the overlaped
/// current range, it will replace the value numbers of the overlaped
/// segments with the specified value number.
void LiveInterval::MergeValueInAsValue(const LiveInterval &RHS,
const VNInfo *RHSValNo,
VNInfo *LHSValNo) {
void LiveRange::MergeValueInAsValue(const LiveRange &RHS,
const VNInfo *RHSValNo,
VNInfo *LHSValNo) {
LiveRangeUpdater Updater(this);
for (const_iterator I = RHS.begin(), E = RHS.end(); I != E; ++I)
if (I->valno == RHSValNo)
@ -521,7 +515,7 @@ void LiveInterval::MergeValueInAsValue(const LiveInterval &RHS,
/// are found to be equivalent. This eliminates V1, replacing all
/// segments with the V1 value number with the V2 value number. This can
/// cause merging of V1/V2 values numbers and compaction of the value space.
VNInfo* LiveInterval::MergeValueNumberInto(VNInfo *V1, VNInfo *V2) {
VNInfo *LiveRange::MergeValueNumberInto(VNInfo *V1, VNInfo *V2) {
assert(V1 != V2 && "Identical value#'s are always equivalent!");
// This code actually merges the (numerically) larger value number into the
@ -583,17 +577,17 @@ unsigned LiveInterval::getSize() const {
return Sum;
}
raw_ostream& llvm::operator<<(raw_ostream& os, const LiveInterval::Segment &S) {
raw_ostream& llvm::operator<<(raw_ostream& os, const LiveRange::Segment &S) {
return os << '[' << S.start << ',' << S.end << ':' << S.valno->id << ")";
}
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
void LiveInterval::Segment::dump() const {
void LiveRange::Segment::dump() const {
dbgs() << *this << "\n";
}
#endif
void LiveInterval::print(raw_ostream &OS) const {
void LiveRange::print(raw_ostream &OS) const {
if (empty())
OS << "EMPTY";
else {
@ -624,18 +618,19 @@ void LiveInterval::print(raw_ostream &OS) const {
}
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
void LiveInterval::dump() const {
void LiveRange::dump() const {
dbgs() << *this << "\n";
}
#endif
#ifndef NDEBUG
void LiveInterval::verify() const {
void LiveRange::verify() const {
for (const_iterator I = begin(), E = end(); I != E; ++I) {
assert(I->start.isValid());
assert(I->end.isValid());
assert(I->start < I->end);
assert(I->valno != 0);
assert(I->valno->id < valnos.size());
assert(I->valno == valnos[I->valno->id]);
if (llvm::next(I) != E) {
assert(I->end <= llvm::next(I)->start);
@ -659,11 +654,11 @@ void LiveInterval::verify() const {
//
// Otherwise, segments are kept in three separate areas:
//
// 1. [begin; WriteI) at the front of LI.
// 2. [ReadI; end) at the back of LI.
// 1. [begin; WriteI) at the front of LR.
// 2. [ReadI; end) at the back of LR.
// 3. Spills.
//
// - LI.begin() <= WriteI <= ReadI <= LI.end().
// - LR.begin() <= WriteI <= ReadI <= LR.end().
// - Segments in all three areas are fully ordered and coalesced.
// - Segments in area 1 precede and can't coalesce with segments in area 2.
// - Segments in Spills precede and can't coalesce with segments in area 2.
@ -678,23 +673,23 @@ void LiveInterval::verify() const {
void LiveRangeUpdater::print(raw_ostream &OS) const {
if (!isDirty()) {
if (LI)
OS << "Clean " << PrintReg(LI->reg) << " updater: " << *LI << '\n';
if (LR)
OS << "Clean updater: " << *LR << '\n';
else
OS << "Null updater.\n";
return;
}
assert(LI && "Can't have null LI in dirty updater.");
OS << PrintReg(LI->reg) << " updater with gap = " << (ReadI - WriteI)
assert(LR && "Can't have null LR in dirty updater.");
OS << " updater with gap = " << (ReadI - WriteI)
<< ", last start = " << LastStart
<< ":\n Area 1:";
for (LiveInterval::const_iterator I = LI->begin(); I != WriteI; ++I)
for (LiveRange::const_iterator I = LR->begin(); I != WriteI; ++I)
OS << ' ' << *I;
OS << "\n Spills:";
for (unsigned I = 0, E = Spills.size(); I != E; ++I)
OS << ' ' << Spills[I];
OS << "\n Area 2:";
for (LiveInterval::const_iterator I = ReadI, E = LI->end(); I != E; ++I)
for (LiveRange::const_iterator I = ReadI, E = LR->end(); I != E; ++I)
OS << ' ' << *I;
OS << '\n';
}
@ -705,8 +700,8 @@ void LiveRangeUpdater::dump() const
}
// Determine if A and B should be coalesced.
static inline bool coalescable(const LiveInterval::Segment &A,
const LiveInterval::Segment &B) {
static inline bool coalescable(const LiveRange::Segment &A,
const LiveRange::Segment &B) {
assert(A.start <= B.start && "Unordered live segments.");
if (A.end == B.start)
return A.valno == B.valno;
@ -716,8 +711,8 @@ static inline bool coalescable(const LiveInterval::Segment &A,
return true;
}
void LiveRangeUpdater::add(LiveInterval::Segment Seg) {
assert(LI && "Cannot add to a null destination");
void LiveRangeUpdater::add(LiveRange::Segment Seg) {
assert(LR && "Cannot add to a null destination");
// Flush the state if Start moves backwards.
if (!LastStart.isValid() || LastStart > Seg.start) {
@ -725,21 +720,21 @@ void LiveRangeUpdater::add(LiveInterval::Segment Seg) {
flush();
// This brings us to an uninitialized state. Reinitialize.
assert(Spills.empty() && "Leftover spilled segments");
WriteI = ReadI = LI->begin();
WriteI = ReadI = LR->begin();
}
// Remember start for next time.
LastStart = Seg.start;
// Advance ReadI until it ends after Seg.start.
LiveInterval::iterator E = LI->end();
LiveRange::iterator E = LR->end();
if (ReadI != E && ReadI->end <= Seg.start) {
// First try to close the gap between WriteI and ReadI with spills.
if (ReadI != WriteI)
mergeSpills();
// Then advance ReadI.
if (ReadI == WriteI)
ReadI = WriteI = LI->find(Seg.start);
ReadI = WriteI = LR->find(Seg.start);
else
while (ReadI != E && ReadI->end <= Seg.start)
*WriteI++ = *ReadI++;
@ -772,7 +767,7 @@ void LiveRangeUpdater::add(LiveInterval::Segment Seg) {
}
// Try coalescing Seg into WriteI[-1].
if (WriteI != LI->begin() && coalescable(WriteI[-1], Seg)) {
if (WriteI != LR->begin() && coalescable(WriteI[-1], Seg)) {
WriteI[-1].end = std::max(WriteI[-1].end, Seg.end);
return;
}
@ -783,10 +778,10 @@ void LiveRangeUpdater::add(LiveInterval::Segment Seg) {
return;
}
// Finally, append to LI or Spills.
// Finally, append to LR or Spills.
if (WriteI == E) {
LI->segments.push_back(Seg);
WriteI = ReadI = LI->end();
LR->segments.push_back(Seg);
WriteI = ReadI = LR->end();
} else
Spills.push_back(Seg);
}
@ -797,10 +792,10 @@ void LiveRangeUpdater::mergeSpills() {
// Perform a backwards merge of Spills and [SpillI;WriteI).
size_t GapSize = ReadI - WriteI;
size_t NumMoved = std::min(Spills.size(), GapSize);
LiveInterval::iterator Src = WriteI;
LiveInterval::iterator Dst = Src + NumMoved;
LiveInterval::iterator SpillSrc = Spills.end();
LiveInterval::iterator B = LI->begin();
LiveRange::iterator Src = WriteI;
LiveRange::iterator Dst = Src + NumMoved;
LiveRange::iterator SpillSrc = Spills.end();
LiveRange::iterator B = LR->begin();
// This is the new WriteI position after merging spills.
WriteI = Dst;
@ -822,12 +817,12 @@ void LiveRangeUpdater::flush() {
// Clear the dirty state.
LastStart = SlotIndex();
assert(LI && "Cannot add to a null destination");
assert(LR && "Cannot add to a null destination");
// Nothing to merge?
if (Spills.empty()) {
LI->segments.erase(WriteI, ReadI);
LI->verify();
LR->segments.erase(WriteI, ReadI);
LR->verify();
return;
}
@ -835,18 +830,17 @@ void LiveRangeUpdater::flush() {
size_t GapSize = ReadI - WriteI;
if (GapSize < Spills.size()) {
// The gap is too small. Make some room.
size_t WritePos = WriteI - LI->begin();
LI->segments.insert(ReadI, Spills.size() - GapSize,
LiveInterval::Segment());
size_t WritePos = WriteI - LR->begin();
LR->segments.insert(ReadI, Spills.size() - GapSize, LiveRange::Segment());
// This also invalidated ReadI, but it is recomputed below.
WriteI = LI->begin() + WritePos;
WriteI = LR->begin() + WritePos;
} else {
// Shrink the gap if necessary.
LI->segments.erase(WriteI + Spills.size(), ReadI);
LR->segments.erase(WriteI + Spills.size(), ReadI);
}
ReadI = WriteI + Spills.size();
mergeSpills();
LI->verify();
LR->verify();
}
unsigned ConnectedVNInfoEqClasses::Classify(const LiveInterval *LI) {

35
llvm/lib/CodeGen/LiveIntervalAnalysis.cpp
View File

@ -348,15 +348,14 @@ bool LiveIntervals::shrinkToUses(LiveInterval *li,
WorkList.push_back(std::make_pair(Idx, VNI));
}
// Create a new live interval with only minimal live segments per def.
LiveInterval NewLI(li->reg, 0);
// Create new live ranges with only minimal live segments per def.
LiveRange NewLR;
for (LiveInterval::vni_iterator I = li->vni_begin(), E = li->vni_end();
I != E; ++I) {
VNInfo *VNI = *I;
if (VNI->isUnused())
continue;
NewLI.addSegment(LiveInterval::Segment(VNI->def, VNI->def.getDeadSlot(),
VNI));
NewLR.addSegment(LiveRange::Segment(VNI->def, VNI->def.getDeadSlot(), VNI));
}
// Keep track of the PHIs that are in use.
@ -371,7 +370,7 @@ bool LiveIntervals::shrinkToUses(LiveInterval *li,
SlotIndex BlockStart = getMBBStartIdx(MBB);
// Extend the live range for VNI to be live at Idx.
if (VNInfo *ExtVNI = NewLI.extendInBlock(BlockStart, Idx)) {
if (VNInfo *ExtVNI = NewLR.extendInBlock(BlockStart, Idx)) {
(void)ExtVNI;
assert(ExtVNI == VNI && "Unexpected existing value number");
// Is this a PHIDef we haven't seen before?
@ -392,7 +391,7 @@ bool LiveIntervals::shrinkToUses(LiveInterval *li,
// VNI is live-in to MBB.
DEBUG(dbgs() << " live-in at " << BlockStart << '\n');
NewLI.addSegment(LiveInterval::Segment(BlockStart, Idx, VNI));
NewLR.addSegment(LiveRange::Segment(BlockStart, Idx, VNI));
// Make sure VNI is live-out from the predecessors.
for (MachineBasicBlock::const_pred_iterator PI = MBB->pred_begin(),
@ -413,14 +412,14 @@ bool LiveIntervals::shrinkToUses(LiveInterval *li,
VNInfo *VNI = *I;
if (VNI->isUnused())
continue;
LiveInterval::iterator LII = NewLI.FindSegmentContaining(VNI->def);
assert(LII != NewLI.end() && "Missing segment for PHI");
if (LII->end != VNI->def.getDeadSlot())
LiveRange::iterator LRI = NewLR.FindSegmentContaining(VNI->def);
assert(LRI != NewLR.end() && "Missing segment for PHI");
if (LRI->end != VNI->def.getDeadSlot())
continue;
if (VNI->isPHIDef()) {
// This is a dead PHI. Remove it.
VNI->markUnused();
NewLI.removeSegment(*LII);
NewLR.removeSegment(LRI->start, LRI->end);
DEBUG(dbgs() << "Dead PHI at " << VNI->def << " may separate interval\n");
CanSeparate = true;
} else {
@ -436,7 +435,7 @@ bool LiveIntervals::shrinkToUses(LiveInterval *li,
}
// Move the trimmed segments back.
li->segments.swap(NewLI.segments);
li->segments.swap(NewLR.segments);
DEBUG(dbgs() << "Shrunk: " << *li << '\n');
return CanSeparate;
}
@ -625,13 +624,13 @@ LiveIntervals::getSpillWeight(bool isDef, bool isUse, BlockFrequency freq) {
return (isDef + isUse) * (freq.getFrequency() * Scale);
}
LiveInterval::Segment
LiveRange::Segment
LiveIntervals::addSegmentToEndOfBlock(unsigned reg, MachineInstr* startInst) {
LiveInterval& Interval = createEmptyInterval(reg);
VNInfo* VN = Interval.getNextValue(
SlotIndex(getInstructionIndex(startInst).getRegSlot()),
getVNInfoAllocator());
LiveInterval::Segment S(
LiveRange::Segment S(
SlotIndex(getInstructionIndex(startInst).getRegSlot()),
getMBBEndIdx(startInst->getParent()), VN);
Interval.addSegment(S);
@ -871,7 +870,7 @@ private:
assert(NewI != I && "Inconsistent iterators");
std::copy(llvm::next(I), NewI, I);
*llvm::prior(NewI)
= LiveInterval::Segment(DefVNI->def, NewIdx.getDeadSlot(), DefVNI);
= LiveRange::Segment(DefVNI->def, NewIdx.getDeadSlot(), DefVNI);
}
/// Update LI to reflect an instruction has been moved upwards from OldIdx
@ -952,7 +951,7 @@ private:
// DefVNI is a dead def. It may have been moved across other values in LI,
// so move I up to NewI. Slide [NewI;I) down one position.
std::copy_backward(NewI, I, llvm::next(I));
*NewI = LiveInterval::Segment(DefVNI->def, NewIdx.getDeadSlot(), DefVNI);
*NewI = LiveRange::Segment(DefVNI->def, NewIdx.getDeadSlot(), DefVNI);
}
void updateRegMaskSlots() {
@ -1143,13 +1142,13 @@ LiveIntervals::repairIntervalsInRange(MachineBasicBlock *MBB,
if (!lastUseIdx.isValid()) {
VNInfo *VNI = LI.getNextValue(instrIdx.getRegSlot(),
VNInfoAllocator);
LiveInterval::Segment S(instrIdx.getRegSlot(),
instrIdx.getDeadSlot(), VNI);
LiveRange::Segment S(instrIdx.getRegSlot(),
instrIdx.getDeadSlot(), VNI);
LII = LI.addSegment(S);
} else if (LII->start != instrIdx.getRegSlot()) {
VNInfo *VNI = LI.getNextValue(instrIdx.getRegSlot(),
VNInfoAllocator);
LiveInterval::Segment S(instrIdx.getRegSlot(), lastUseIdx, VNI);
LiveRange::Segment S(instrIdx.getRegSlot(), lastUseIdx, VNI);
LII = LI.addSegment(S);
}