replica
/
hanchenye-llvm-project
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Pull Interval class out of LiveIntervals. 

llvm-svn: 13910
This commit is contained in:
Alkis Evlogimenos 2004-05-30 07:46:27 +00:00
parent 34f6bcc8d2
commit fbe799cfa2
3 changed files with 78 additions and 91 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

30
llvm/lib/CodeGen/LiveIntervals.cpp
View File

@ -167,7 +167,7 @@ bool LiveIntervals::runOnMachineFunction(MachineFunction &fn) {
} }
} }
intervals_.sort(StartPointComp()); intervals_.sort();
DEBUG(std::cerr << "********** INTERVALS **********\n"); DEBUG(std::cerr << "********** INTERVALS **********\n");
DEBUG(std::copy(intervals_.begin(), intervals_.end(), DEBUG(std::copy(intervals_.begin(), intervals_.end(),
std::ostream_iterator<Interval>(std::cerr, "\n"))); std::ostream_iterator<Interval>(std::cerr, "\n")));
@ -186,8 +186,7 @@ bool LiveIntervals::runOnMachineFunction(MachineFunction &fn) {
return true; return true;
} }
std::vector<LiveIntervals::Interval*> std::vector<Interval*> LiveIntervals::addIntervalsForSpills(const Interval& li,
LiveIntervals::addIntervalsForSpills(const Interval& li,
VirtRegMap& vrm, VirtRegMap& vrm,
int slot) int slot)
{ {
@ -554,7 +553,7 @@ bool LiveIntervals::overlapsAliases(const Interval& lhs,
return false; return false;
} }
LiveIntervals::Interval& LiveIntervals::getOrCreateInterval(unsigned reg) Interval& LiveIntervals::getOrCreateInterval(unsigned reg)
{ {
Reg2IntervalMap::iterator r2iit = r2iMap_.lower_bound(reg); Reg2IntervalMap::iterator r2iit = r2iMap_.lower_bound(reg);
if (r2iit == r2iMap_.end() || r2iit->first != reg) { if (r2iit == r2iMap_.end() || r2iit->first != reg) {
@ -565,13 +564,13 @@ LiveIntervals::Interval& LiveIntervals::getOrCreateInterval(unsigned reg)
return *r2iit->second; return *r2iit->second;
} }
LiveIntervals::Interval::Interval(unsigned r) Interval::Interval(unsigned r)
: reg(r), : reg(r),
weight((MRegisterInfo::isPhysicalRegister(r) ? HUGE_VAL : 0.0F)) weight((MRegisterInfo::isPhysicalRegister(r) ? HUGE_VAL : 0.0F))
{ {
} }
bool LiveIntervals::Interval::spilled() const bool Interval::spilled() const
{ {
return (weight == HUGE_VAL && return (weight == HUGE_VAL &&
MRegisterInfo::isVirtualRegister(reg)); MRegisterInfo::isVirtualRegister(reg));
@ -584,7 +583,7 @@ bool LiveIntervals::Interval::spilled() const
// definition of the variable it represents. This is because slot 1 is // definition of the variable it represents. This is because slot 1 is
// used (def slot) and spans up to slot 3 (store slot). // used (def slot) and spans up to slot 3 (store slot).
// //
bool LiveIntervals::Interval::liveAt(unsigned index) const bool Interval::liveAt(unsigned index) const
{ {
Range dummy(index, index+1); Range dummy(index, index+1);
Ranges::const_iterator r = std::upper_bound(ranges.begin(), Ranges::const_iterator r = std::upper_bound(ranges.begin(),
@ -611,7 +610,7 @@ bool LiveIntervals::Interval::liveAt(unsigned index) const
// //
// A->overlaps(C) should return false since we want to be able to join // A->overlaps(C) should return false since we want to be able to join
// A and C. // A and C.
bool LiveIntervals::Interval::overlaps(const Interval& other) const bool Interval::overlaps(const Interval& other) const
{ {
Ranges::const_iterator i = ranges.begin(); Ranges::const_iterator i = ranges.begin();
Ranges::const_iterator ie = ranges.end(); Ranges::const_iterator ie = ranges.end();
@ -649,7 +648,7 @@ bool LiveIntervals::Interval::overlaps(const Interval& other) const
return false; return false;
} }
void LiveIntervals::Interval::addRange(unsigned start, unsigned end) void Interval::addRange(unsigned start, unsigned end)
{ {
assert(start < end && "Invalid range to add!"); assert(start < end && "Invalid range to add!");
DEBUG(std::cerr << " +[" << start << ',' << end << ")"); DEBUG(std::cerr << " +[" << start << ',' << end << ")");
@ -663,7 +662,7 @@ void LiveIntervals::Interval::addRange(unsigned start, unsigned end)
it = mergeRangesBackward(it); it = mergeRangesBackward(it);
} }
void LiveIntervals::Interval::join(const LiveIntervals::Interval& other) void Interval::join(const Interval& other)
{ {
DEBUG(std::cerr << "\t\tjoining " << *this << " with " << other << '\n'); DEBUG(std::cerr << "\t\tjoining " << *this << " with " << other << '\n');
Ranges::iterator cur = ranges.begin(); Ranges::iterator cur = ranges.begin();
@ -678,8 +677,7 @@ void LiveIntervals::Interval::join(const LiveIntervals::Interval& other)
++numJoins; ++numJoins;
} }
LiveIntervals::Interval::Ranges::iterator Interval::Ranges::iterator Interval::mergeRangesForward(Ranges::iterator it)
LiveIntervals::Interval::mergeRangesForward(Ranges::iterator it)
{ {
Ranges::iterator n; Ranges::iterator n;
while ((n = next(it)) != ranges.end()) { while ((n = next(it)) != ranges.end()) {
@ -691,8 +689,7 @@ LiveIntervals::Interval::mergeRangesForward(Ranges::iterator it)
return it; return it;
} }
LiveIntervals::Interval::Ranges::iterator Interval::Ranges::iterator Interval::mergeRangesBackward(Ranges::iterator it)
LiveIntervals::Interval::mergeRangesBackward(Ranges::iterator it)
{ {
while (it != ranges.begin()) { while (it != ranges.begin()) {
Ranges::iterator p = prior(it); Ranges::iterator p = prior(it);
@ -707,15 +704,14 @@ LiveIntervals::Interval::mergeRangesBackward(Ranges::iterator it)
return it; return it;
} }
std::ostream& llvm::operator<<(std::ostream& os, std::ostream& llvm::operator<<(std::ostream& os, const Interval& li)
const LiveIntervals::Interval& li)
{ {
os << "%reg" << li.reg << ',' << li.weight; os << "%reg" << li.reg << ',' << li.weight;
if (li.empty()) if (li.empty())
return os << "EMPTY"; return os << "EMPTY";
os << " = "; os << " = ";
for (LiveIntervals::Interval::Ranges::const_iterator for (Interval::Ranges::const_iterator
i = li.ranges.begin(), e = li.ranges.end(); i != e; ++i) { i = li.ranges.begin(), e = li.ranges.end(); i != e; ++i) {
os << "[" << i->first << "," << i->second << ")"; os << "[" << i->first << "," << i->second << ")";
} }

42
llvm/lib/CodeGen/LiveIntervals.h
View File

@ -30,17 +30,15 @@ namespace llvm {
class MRegisterInfo; class MRegisterInfo;
class VirtRegMap; class VirtRegMap;
class LiveIntervals : public MachineFunctionPass
{
public:
struct Interval { struct Interval {
typedef std::pair<unsigned, unsigned> Range; typedef std::pair<unsigned, unsigned> Range;
typedef std::vector<Range> Ranges; typedef std::vector<Range> Ranges;
unsigned reg; // the register of this interval unsigned reg; // the register of this interval
float weight; // weight of this interval (number of uses float weight; // weight of this interval:
// * 10^loopDepth) // (number of uses *10^loopDepth)
Ranges ranges; // the ranges in which this register is live Ranges ranges; // the ranges in which this register is live
Interval(unsigned r);
explicit Interval(unsigned r);
bool empty() const { return ranges.empty(); } bool empty() const { return ranges.empty(); }
@ -68,24 +66,24 @@ namespace llvm {
void join(const Interval& other); void join(const Interval& other);
bool operator<(const Interval& other) const {
return start() < other.start();
}
bool operator==(const Interval& other) const {
return reg == other.reg;
}
private: private:
Ranges::iterator mergeRangesForward(Ranges::iterator it); Ranges::iterator mergeRangesForward(Ranges::iterator it);
Ranges::iterator mergeRangesBackward(Ranges::iterator it); Ranges::iterator mergeRangesBackward(Ranges::iterator it);
}; };
struct StartPointComp { std::ostream& operator<<(std::ostream& os, const Interval& li);
bool operator()(const Interval& lhs, const Interval& rhs) {
return lhs.ranges.front().first < rhs.ranges.front().first;
}
};
struct StartPointPtrComp {
bool operator()(const Interval* lhs, const Interval* rhs) {
return lhs->ranges.front().first < rhs->ranges.front().first;
}
};
class LiveIntervals : public MachineFunctionPass
{
public:
typedef std::list<Interval> Intervals; typedef std::list<Interval> Intervals;
private: private:
@ -205,14 +203,6 @@ namespace llvm {
void printRegName(unsigned reg) const; void printRegName(unsigned reg) const;
}; };
inline bool operator==(const LiveIntervals::Interval& lhs,
const LiveIntervals::Interval& rhs) {
return lhs.reg == rhs.reg;
}
std::ostream& operator<<(std::ostream& os,
const LiveIntervals::Interval& li);
} // End llvm namespace } // End llvm namespace
#endif #endif

23
llvm/lib/CodeGen/RegAllocLinearScan.cpp
View File

@ -21,6 +21,7 @@
#include "llvm/Target/MRegisterInfo.h" #include "llvm/Target/MRegisterInfo.h"
#include "llvm/Target/TargetMachine.h" #include "llvm/Target/TargetMachine.h"
#include "Support/Debug.h" #include "Support/Debug.h"
#include "Support/STLExtras.h"
#include "LiveIntervals.h" #include "LiveIntervals.h"
#include "PhysRegTracker.h" #include "PhysRegTracker.h"
#include "VirtRegMap.h" #include "VirtRegMap.h"
@ -38,7 +39,7 @@ namespace {
const TargetMachine* tm_; const TargetMachine* tm_;
const MRegisterInfo* mri_; const MRegisterInfo* mri_;
LiveIntervals* li_; LiveIntervals* li_;
typedef std::list<LiveIntervals::Interval*> IntervalPtrs; typedef std::list<Interval*> IntervalPtrs;
IntervalPtrs unhandled_, fixed_, active_, inactive_, handled_; IntervalPtrs unhandled_, fixed_, active_, inactive_, handled_;
std::auto_ptr<PhysRegTracker> prt_; std::auto_ptr<PhysRegTracker> prt_;
@ -122,7 +123,7 @@ namespace {
// if (MRegisterInfo::isVirtualRegister(i->second) && // if (MRegisterInfo::isVirtualRegister(i->second) &&
// (i->second == i2->second || // (i->second == i2->second ||
// mri_->areAliases(i->second, i2->second))) { // mri_->areAliases(i->second, i2->second))) {
// const LiveIntervals::Interval // const Interval
// &in = li_->getInterval(i->second), // &in = li_->getInterval(i->second),
// &in2 = li_->getInterval(i2->second); // &in2 = li_->getInterval(i2->second);
// if (in.overlaps(in2)) { // if (in.overlaps(in2)) {
@ -373,12 +374,12 @@ void RA::assignRegOrStackSlotAtInterval(IntervalPtrs::value_type cur)
if (cur->weight <= minWeight) { if (cur->weight <= minWeight) {
DEBUG(std::cerr << "\t\t\tspilling(c): " << *cur << '\n';); DEBUG(std::cerr << "\t\t\tspilling(c): " << *cur << '\n';);
int slot = vrm_->assignVirt2StackSlot(cur->reg); int slot = vrm_->assignVirt2StackSlot(cur->reg);
std::vector<LiveIntervals::Interval*> added = std::vector<Interval*> added =
li_->addIntervalsForSpills(*cur, *vrm_, slot); li_->addIntervalsForSpills(*cur, *vrm_, slot);
// merge added with unhandled // merge added with unhandled
std::vector<LiveIntervals::Interval*>::iterator addedIt = added.begin(); std::vector<Interval*>::iterator addedIt = added.begin();
std::vector<LiveIntervals::Interval*>::iterator addedItEnd = added.end(); std::vector<Interval*>::iterator addedItEnd = added.end();
for (IntervalPtrs::iterator i = unhandled_.begin(), e = unhandled_.end(); for (IntervalPtrs::iterator i = unhandled_.begin(), e = unhandled_.end();
i != e && addedIt != addedItEnd; ++i) { i != e && addedIt != addedItEnd; ++i) {
if ((*i)->start() > (*addedIt)->start()) if ((*i)->start() > (*addedIt)->start())
@ -398,7 +399,7 @@ void RA::assignRegOrStackSlotAtInterval(IntervalPtrs::value_type cur)
// otherwise we spill all intervals aliasing the register with // otherwise we spill all intervals aliasing the register with
// minimum weight, rollback to the interval with the earliest // minimum weight, rollback to the interval with the earliest
// start point and let the linear scan algorithm run again // start point and let the linear scan algorithm run again
std::vector<LiveIntervals::Interval*> added; std::vector<Interval*> added;
assert(MRegisterInfo::isPhysicalRegister(minReg) && assert(MRegisterInfo::isPhysicalRegister(minReg) &&
"did not choose a register to spill?"); "did not choose a register to spill?");
std::vector<bool> toSpill(mri_->getNumRegs(), false); std::vector<bool> toSpill(mri_->getNumRegs(), false);
@ -417,7 +418,7 @@ void RA::assignRegOrStackSlotAtInterval(IntervalPtrs::value_type cur)
DEBUG(std::cerr << "\t\t\tspilling(a): " << **i << '\n'); DEBUG(std::cerr << "\t\t\tspilling(a): " << **i << '\n');
earliestStart = std::min(earliestStart, (*i)->start()); earliestStart = std::min(earliestStart, (*i)->start());
int slot = vrm_->assignVirt2StackSlot((*i)->reg); int slot = vrm_->assignVirt2StackSlot((*i)->reg);
std::vector<LiveIntervals::Interval*> newIs = std::vector<Interval*> newIs =
li_->addIntervalsForSpills(**i, *vrm_, slot); li_->addIntervalsForSpills(**i, *vrm_, slot);
std::copy(newIs.begin(), newIs.end(), std::back_inserter(added)); std::copy(newIs.begin(), newIs.end(), std::back_inserter(added));
spilled.insert(reg); spilled.insert(reg);
@ -432,7 +433,7 @@ void RA::assignRegOrStackSlotAtInterval(IntervalPtrs::value_type cur)
DEBUG(std::cerr << "\t\t\tspilling(i): " << **i << '\n'); DEBUG(std::cerr << "\t\t\tspilling(i): " << **i << '\n');
earliestStart = std::min(earliestStart, (*i)->start()); earliestStart = std::min(earliestStart, (*i)->start());
int slot = vrm_->assignVirt2StackSlot((*i)->reg); int slot = vrm_->assignVirt2StackSlot((*i)->reg);
std::vector<LiveIntervals::Interval*> newIs = std::vector<Interval*> newIs =
li_->addIntervalsForSpills(**i, *vrm_, slot); li_->addIntervalsForSpills(**i, *vrm_, slot);
std::copy(newIs.begin(), newIs.end(), std::back_inserter(added)); std::copy(newIs.begin(), newIs.end(), std::back_inserter(added));
spilled.insert(reg); spilled.insert(reg);
@ -495,10 +496,10 @@ void RA::assignRegOrStackSlotAtInterval(IntervalPtrs::value_type cur)
} }
} }
std::sort(added.begin(), added.end(), LiveIntervals::StartPointPtrComp()); std::sort(added.begin(), added.end(), less_ptr<Interval>());
// merge added with unhandled // merge added with unhandled
std::vector<LiveIntervals::Interval*>::iterator addedIt = added.begin(); std::vector<Interval*>::iterator addedIt = added.begin();
std::vector<LiveIntervals::Interval*>::iterator addedItEnd = added.end(); std::vector<Interval*>::iterator addedItEnd = added.end();
for (IntervalPtrs::iterator i = unhandled_.begin(), e = unhandled_.end(); for (IntervalPtrs::iterator i = unhandled_.begin(), e = unhandled_.end();
i != e && addedIt != addedItEnd; ++i) { i != e && addedIt != addedItEnd; ++i) {
if ((*i)->start() > (*addedIt)->start()) if ((*i)->start() > (*addedIt)->start())