: reg(Reg), weight(Weight), NumValues(0) {
}
+ typedef Ranges::iterator iterator;
+ iterator begin() { return ranges.begin(); }
+ iterator end() { return ranges.end(); }
+
+ typedef Ranges::const_iterator const_iterator;
+ const_iterator begin() const { return ranges.begin(); }
+ const_iterator end() const { return ranges.end(); }
+
+
+ /// advanceTo - Advance the specified iterator to point to the LiveRange
+ /// containing the specified position, or end() if the position is past the
+ /// end of the interval. If no LiveRange contains this position, but the
+ /// position is in a hole, this method returns an iterator pointing the the
+ /// LiveRange immediately after the hole.
+ iterator advanceTo(iterator I, unsigned Pos) {
+ if (Pos >= endNumber())
+ return end();
+ while (I->end <= Pos) ++I;
+ return I;
+ }
+
void swap(LiveInterval& other) {
std::swap(reg, other.reg);
std::swap(weight, other.weight);
bool empty() const { return ranges.empty(); }
- /// start - Return the lowest numbered slot covered by interval.
- unsigned start() const {
+ /// beginNumber - Return the lowest numbered slot covered by interval.
+ unsigned beginNumber() const {
assert(!empty() && "empty interval for register");
return ranges.front().start;
}
- /// end - return the maximum point of the interval of the whole,
+ /// endNumber - return the maximum point of the interval of the whole,
/// exclusive.
- unsigned end() const {
+ unsigned endNumber() const {
assert(!empty() && "empty interval for register");
return ranges.back().end;
}
bool expiredAt(unsigned index) const {
- return end() <= (index + 1);
+ return index >= endNumber();
}
bool liveAt(unsigned index) const;
bool joinable(const LiveInterval& other, unsigned CopyIdx) const;
- bool overlaps(const LiveInterval& other) const;
+ /// overlaps - Return true if the intersection of the two live intervals is
+ /// not empty.
+ bool overlaps(const LiveInterval& other) const {
+ return overlapsFrom(other, other.begin());
+ }
+
+ /// overlapsFrom - Return true if the intersection of the two live intervals
+ /// 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;
/// addRange - Add the specified LiveRange to this interval, merging
/// intervals as appropriate. This returns an iterator to the inserted live
void removeRange(unsigned Start, unsigned End);
bool operator<(const LiveInterval& other) const {
- return start() < other.start();
+ return beginNumber() < other.beginNumber();
}
void dump() const;