6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2025-04-14 06:37:33 +00:00
Code Issues Projects Releases Wiki Activity

Clean up the Spiller.h interface.

Browse Source 
The earliestStart argument is entirely specific to linear scan allocation, and
can be easily calculated by RegAllocLinearScan.

Replace std::vector with SmallVector.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@111055 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Jakob Stoklund Olesen 2010-08-13 22:56:53 +00:00
parent 703af3ab12
commit 0a2b2a1497
6 changed files with 31 additions and 44 deletions

12
lib/CodeGen/InlineSpiller.cpp

@ -45,7 +45,7 @@ class InlineSpiller : public Spiller {
// Variables that are valid during spill(), but used by multiple methods.
LiveInterval *li_;
std::vector<LiveInterval*> *newIntervals_;
SmallVectorImpl<LiveInterval*> *newIntervals_;
const TargetRegisterClass *rc_;
int stackSlot_;
const SmallVectorImpl<LiveInterval*> *spillIs_;
@ -75,9 +75,8 @@ public:
splitAnalysis_(mf, lis_, loops_) {}
void spill(LiveInterval *li,
std::vector<LiveInterval*> &newIntervals,
SmallVectorImpl<LiveInterval*> &spillIs,
SlotIndex *earliestIndex);
SmallVectorImpl<LiveInterval*> &newIntervals,
SmallVectorImpl<LiveInterval*> &spillIs);
private:
bool split();
@ -388,9 +387,8 @@ void InlineSpiller::insertSpill(LiveInterval &NewLI,
}
void InlineSpiller::spill(LiveInterval *li,
std::vector<LiveInterval*> &newIntervals,
SmallVectorImpl<LiveInterval*> &spillIs,
SlotIndex *earliestIndex) {
SmallVectorImpl<LiveInterval*> &newIntervals,
SmallVectorImpl<LiveInterval*> &spillIs) {
DEBUG(dbgs() << "Inline spilling " << *li << "\n");
assert(li->isSpillable() && "Attempting to spill already spilled value.");
assert(!li->isStackSlot() && "Trying to spill a stack slot.");

17
lib/CodeGen/RegAllocLinearScan.cpp

@ -1202,8 +1202,7 @@ void RALinScan::assignRegOrStackSlotAtInterval(LiveInterval* cur) {
// linearscan.
if (cur->weight != HUGE_VALF && cur->weight <= minWeight) {
DEBUG(dbgs() << "\t\t\tspilling(c): " << *cur << '\n');
SmallVector<LiveInterval*, 8> spillIs;
std::vector<LiveInterval*> added;
SmallVector<LiveInterval*, 8> spillIs, added;
spiller_->spill(cur, added, spillIs);
std::sort(added.begin(), added.end(), LISorter());
@ -1268,25 +1267,31 @@ void RALinScan::assignRegOrStackSlotAtInterval(LiveInterval* cur) {
// in handled we need to roll back
assert(!spillIs.empty() && "No spill intervals?");
SlotIndex earliestStart = spillIs[0]->beginIndex();
// Spill live intervals of virtual regs mapped to the physical register we
// want to clear (and its aliases). We only spill those that overlap with the
// current interval as the rest do not affect its allocation. we also keep
// track of the earliest start of all spilled live intervals since this will
// mark our rollback point.
std::vector<LiveInterval*> added;
SmallVector<LiveInterval*, 8> added;
while (!spillIs.empty()) {
LiveInterval *sli = spillIs.back();
spillIs.pop_back();
DEBUG(dbgs() << "\t\t\tspilling(a): " << *sli << '\n');
if (sli->beginIndex() < earliestStart)
earliestStart = sli->beginIndex();
spiller_->spill(sli, added, spillIs, &earliestStart);
spiller_->spill(sli, added, spillIs);
addStackInterval(sli, ls_, li_, mri_, *vrm_);
spilled.insert(sli->reg);
}
// Include any added intervals in earliestStart.
for (unsigned i = 0, e = added.size(); i != e; ++i) {
SlotIndex SI = added[i]->beginIndex();
if (SI < earliestStart)
earliestStart = SI;
}
DEBUG(dbgs() << "\t\trolling back to: " << earliestStart << '\n');
// Scan handled in reverse order up to the earliest start of a

32
lib/CodeGen/Spiller.cpp

@ -74,7 +74,7 @@ protected:
/// immediately before each use, and stores after each def. No folding or
/// remat is attempted.
void trivialSpillEverywhere(LiveInterval *li,
std::vector<LiveInterval*> &newIntervals) {
SmallVectorImpl<LiveInterval*> &newIntervals) {
DEBUG(dbgs() << "Spilling everywhere " << *li << "\n");
assert(li->weight != HUGE_VALF &&
@ -181,9 +181,8 @@ public:
: SpillerBase(pass, mf, vrm) {}
void spill(LiveInterval *li,
std::vector<LiveInterval*> &newIntervals,
SmallVectorImpl<LiveInterval*> &,
SlotIndex*) {
SmallVectorImpl<LiveInterval*> &newIntervals,
SmallVectorImpl<LiveInterval*> &) {
// Ignore spillIs - we don't use it.
trivialSpillEverywhere(li, newIntervals);
}
@ -208,9 +207,8 @@ public:
/// Falls back on LiveIntervals::addIntervalsForSpills.
void spill(LiveInterval *li,
std::vector<LiveInterval*> &newIntervals,
SmallVectorImpl<LiveInterval*> &spillIs,
SlotIndex*) {
SmallVectorImpl<LiveInterval*> &newIntervals,
SmallVectorImpl<LiveInterval*> &spillIs) {
std::vector<LiveInterval*> added =
lis->addIntervalsForSpills(*li, spillIs, loopInfo, *vrm);
newIntervals.insert(newIntervals.end(), added.begin(), added.end());
@ -236,13 +234,12 @@ public:
}
void spill(LiveInterval *li,
std::vector<LiveInterval*> &newIntervals,
SmallVectorImpl<LiveInterval*> &spillIs,
SlotIndex *earliestStart) {
SmallVectorImpl<LiveInterval*> &newIntervals,
SmallVectorImpl<LiveInterval*> &spillIs) {
if (worthTryingToSplit(li))
tryVNISplit(li, earliestStart);
tryVNISplit(li);
else
StandardSpiller::spill(li, newIntervals, spillIs, earliestStart);
StandardSpiller::spill(li, newIntervals, spillIs);
}
private:
@ -257,8 +254,7 @@ private:
}
/// Try to break a LiveInterval into its component values.
std::vector<LiveInterval*> tryVNISplit(LiveInterval *li,
SlotIndex *earliestStart) {
std::vector<LiveInterval*> tryVNISplit(LiveInterval *li) {
DEBUG(dbgs() << "Trying VNI split of %reg" << *li << "\n");
@ -282,10 +278,6 @@ private:
DEBUG(dbgs() << *splitInterval << "\n");
added.push_back(splitInterval);
alreadySplit.insert(splitInterval);
if (earliestStart != 0) {
if (splitInterval->beginIndex() < *earliestStart)
*earliestStart = splitInterval->beginIndex();
}
} else {
DEBUG(dbgs() << "0\n");
}
@ -298,10 +290,6 @@ private:
if (!li->empty()) {
added.push_back(li);
alreadySplit.insert(li);
if (earliestStart != 0) {
if (li->beginIndex() < *earliestStart)
*earliestStart = li->beginIndex();
}
}
return added;

8
lib/CodeGen/Spiller.h

@ -11,7 +11,6 @@
#define LLVM_CODEGEN_SPILLER_H
#include "llvm/ADT/SmallVector.h"
#include <vector>
namespace llvm {
@ -36,12 +35,9 @@ namespace llvm {
/// @param spillIs A list of intervals that are about to be spilled,
/// and so cannot be used for remat etc.
/// @param newIntervals The newly created intervals will be appended here.
/// @param earliestIndex The earliest point for splitting. (OK, it's another
/// pointer to the allocator guts).
virtual void spill(LiveInterval *li,
std::vector<LiveInterval*> &newIntervals,
SmallVectorImpl<LiveInterval*> &spillIs,
SlotIndex *earliestIndex = 0) = 0;
SmallVectorImpl<LiveInterval*> &newIntervals,
SmallVectorImpl<LiveInterval*> &spillIs) = 0;
};

2
lib/CodeGen/SplitKit.cpp

@ -342,7 +342,7 @@ bool SplitAnalysis::getMultiUseBlocks(BlockPtrSet &Blocks) {
/// Create a new SplitEditor for editing the LiveInterval analyzed by SA.
SplitEditor::SplitEditor(SplitAnalysis &sa, LiveIntervals &lis, VirtRegMap &vrm,
std::vector<LiveInterval*> &intervals)
SmallVectorImpl<LiveInterval*> &intervals)
: sa_(sa), lis_(lis), vrm_(vrm),
mri_(vrm.getMachineFunction().getRegInfo()),
tii_(*vrm.getMachineFunction().getTarget().getInstrInfo()),

4
lib/CodeGen/SplitKit.h

@ -183,7 +183,7 @@ class SplitEditor {
bool liveThrough_;
/// All the new intervals created for this split are added to intervals_.
std::vector<LiveInterval*> &intervals_;
SmallVectorImpl<LiveInterval*> &intervals_;
/// The index into intervals_ of the first interval we added. There may be
/// others from before we got it.
@ -199,7 +199,7 @@ public:
/// Create a new SplitEditor for editing the LiveInterval analyzed by SA.
/// Newly created intervals will be appended to newIntervals.
SplitEditor(SplitAnalysis &SA, LiveIntervals&, VirtRegMap&,
std::vector<LiveInterval*> &newIntervals);
SmallVectorImpl<LiveInterval*> &newIntervals);
/// getAnalysis - Get the corresponding analysis.
SplitAnalysis &getAnalysis() { return sa_; }