[llvm] r192393 - Refactor LiveInterval: introduce new LiveRange class
Matthias Braun
matze at braunis.de
Thu Oct 10 14:28:47 PDT 2013
Author: matze
Date: Thu Oct 10 16:28:47 2013
New Revision: 192393
URL: http://llvm.org/viewvc/llvm-project?rev=192393&view=rev
Log:
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.
Modified:
llvm/trunk/include/llvm/CodeGen/LiveInterval.h
llvm/trunk/include/llvm/CodeGen/LiveIntervalAnalysis.h
llvm/trunk/lib/CodeGen/LiveInterval.cpp
llvm/trunk/lib/CodeGen/LiveIntervalAnalysis.cpp
Modified: llvm/trunk/include/llvm/CodeGen/LiveInterval.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/CodeGen/LiveInterval.h?rev=192393&r1=192392&r2=192393&view=diff
==============================================================================
--- llvm/trunk/include/llvm/CodeGen/LiveInterval.h (original)
+++ llvm/trunk/include/llvm/CodeGen/LiveInterval.h Thu Oct 10 16:28:47 2013
@@ -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?
Modified: llvm/trunk/include/llvm/CodeGen/LiveIntervalAnalysis.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/CodeGen/LiveIntervalAnalysis.h?rev=192393&r1=192392&r2=192393&view=diff
==============================================================================
--- llvm/trunk/include/llvm/CodeGen/LiveIntervalAnalysis.h (original)
+++ llvm/trunk/include/llvm/CodeGen/LiveIntervalAnalysis.h Thu Oct 10 16:28:47 2013
@@ -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 {
Modified: llvm/trunk/lib/CodeGen/LiveInterval.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/CodeGen/LiveInterval.cpp?rev=192393&r1=192392&r2=192393&view=diff
==============================================================================
--- llvm/trunk/lib/CodeGen/LiveInterval.cpp (original)
+++ llvm/trunk/lib/CodeGen/LiveInterval.cpp Thu Oct 10 16:28:47 2013
@@ -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::fin
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(Slot
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(Slot
// 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(Slot
// 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 Li
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 LiveIn
}
}
-/// 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 St
/// 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(
/// 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(it
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(it
/// 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(itera
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,
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(Slot
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(SlotInd
// 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(SlotInd
/// 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 *V
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 &Ot
}
}
- // 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 &Ot
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 &Ot
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 &Ot
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(c
/// 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
}
#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 Liv
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:
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:
}
// 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:
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) {
Modified: llvm/trunk/lib/CodeGen/LiveIntervalAnalysis.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/CodeGen/LiveIntervalAnalysis.cpp?rev=192393&r1=192392&r2=192393&view=diff
==============================================================================
--- llvm/trunk/lib/CodeGen/LiveIntervalAnalysis.cpp (original)
+++ llvm/trunk/lib/CodeGen/LiveIntervalAnalysis.cpp Thu Oct 10 16:28:47 2013
@@ -348,15 +348,14 @@ bool LiveIntervals::shrinkToUses(LiveInt
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(LiveInt
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(LiveInt
// 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(LiveInt
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(LiveInt
}
// 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
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(Ma
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);
}
More information about the llvm-commits
mailing list