6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2025-06-13 22:24:07 +00:00
Code Issues Projects Releases Wiki Activity

Improve comments a bit

Browse Source 
Use an explicit LiveRange class to represent ranges instead of an std::pair.
This is a minor cleanup, but is really intended to make a future patch simpler
and less invasive.

Alkis, could you please take a look at LiveInterval::liveAt?  I suspect that
you can add an operator<(unsigned) to LiveRange, allowing us to speed up the
upper_bound call by quite a bit (this would also apply to other callers of
upper/lower_bound).  I would do it myself, but I still don't understand that
crazy liveAt function, despite the comment. :)

Basically I would like to see this:
    LiveRange dummy(index, index+1);
    Ranges::const_iterator r = std::upper_bound(ranges.begin(),
                                                ranges.end(),
                                                dummy);

Turn into:
    Ranges::const_iterator r = std::upper_bound(ranges.begin(),
                                                ranges.end(),
                                                index);


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@15130 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Chris Lattner
2004-07-23 08:24:23 +00:00
parent 5c2e282865
commit ec2bc64505
3 changed files with 101 additions and 60 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@ -29,9 +29,29 @@ namespace llvm {
class MRegisterInfo;
class VirtRegMap;
/// LiveRange structure - This represents a simple register range in the
/// program, with an inclusive start point and an exclusive end point.
/// These ranges are rendered as [start,end).
struct LiveRange {
unsigned start; // Start point of the interval (inclusive)
unsigned end; // End point of the interval (exclusive)
LiveRange(unsigned S, unsigned E) : start(S), end(E) {
assert(S < E && "Cannot create empty or backwards range");
}
bool operator<(const LiveRange &LR) const {
return start < LR.start || (start == LR.start && end < LR.end);
}
bool operator==(const LiveRange &LR) const {
return start == LR.start && end == LR.end;
}
private:
LiveRange(); // DO NOT IMPLEMENT
};
std::ostream& operator<<(std::ostream& os, const LiveRange &LR);
struct LiveInterval {
typedef std::pair<unsigned, unsigned> Range;
typedef std::vector<Range> Ranges;
typedef std::vector<LiveRange> Ranges;
unsigned reg; // the register of this interval
float weight; // weight of this interval:
// (number of uses *10^loopDepth)
@ -44,14 +64,17 @@ namespace llvm {
bool spilled() const;
/// start - Return the lowest numbered slot covered by interval.
unsigned start() const {
assert(!empty() && "empty interval for register");
return ranges.front().first;
return ranges.front().start;
}
/// end - return the maximum point of the interval of the whole,
/// exclusive.
unsigned end() const {
assert(!empty() && "empty interval for register");
return ranges.back().second;
return ranges.back().end;
}
bool expiredAt(unsigned index) const {
@ -62,7 +85,7 @@ namespace llvm {
bool overlaps(const LiveInterval& other) const;
void addRange(unsigned start, unsigned end);
void addRange(LiveRange R);
void join(const LiveInterval& other);