6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2024-08-25 16:29:20 +00:00
Code Issues Projects Releases Wiki Activity

Use LiveRangeUpdater instead of mergeIntervalRanges.

Browse Source 
Performance is the same, but LiveRangeUpdater has a more flexible
interface.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@175645 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Jakob Stoklund Olesen 2013-02-20 18:18:15 +00:00
parent 1a41f32546
commit d983d4c6ed
2 changed files with 11 additions and 143 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
include/llvm/CodeGen/LiveInterval.h
View File

@ -461,9 +461,6 @@ namespace llvm {
void extendIntervalEndTo(Ranges::iterator I, SlotIndex NewEnd);
Ranges::iterator extendIntervalStartTo(Ranges::iterator I, SlotIndex NewStr);
void markValNoForDeletion(VNInfo *V);
void mergeIntervalRanges(const LiveInterval &RHS,
VNInfo *LHSValNo = 0,
const VNInfo *RHSValNo = 0);
LiveInterval& operator=(const LiveInterval& rhs) LLVM_DELETED_FUNCTION;

151
lib/CodeGen/LiveInterval.cpp
View File

@ -486,148 +486,14 @@ void LiveInterval::join(LiveInterval &Other,
valnos.resize(NumNewVals); // shrinkify
// Okay, now insert the RHS live ranges into the LHS.
LiveRangeUpdater Updater(this);
unsigned RangeNo = 0;
for (iterator I = Other.begin(), E = Other.end(); I != E; ++I, ++RangeNo) {
// Map the valno in the other live range to the current live range.
I->valno = NewVNInfo[OtherAssignments[RangeNo]];
assert(I->valno && "Adding a dead range?");
VNInfo *VNI = NewVNInfo[OtherAssignments[RangeNo]];
assert(VNI && "Adding a dead range?");
Updater.add(I->start, I->end, VNI);
}
mergeIntervalRanges(Other);
verify();
}
/// \brief Helper function for merging in another LiveInterval's ranges.
///
/// This is a helper routine implementing an efficient merge of another
/// LiveIntervals ranges into the current interval.
///
/// \param LHSValNo If non-NULL, set as the new value number for every range
/// from RHS which is merged into the LHS.
/// \param RHSValNo If non-NULL, then only ranges in RHS whose original value
/// number maches this value number will be merged into LHS.
void LiveInterval::mergeIntervalRanges(const LiveInterval &RHS,
VNInfo *LHSValNo,
const VNInfo *RHSValNo) {
if (RHS.empty())
return;
// Ensure we're starting with a valid range. Note that we don't verify RHS
// because it may have had its value numbers adjusted in preparation for
// merging.
verify();
// The strategy for merging these efficiently is as follows:
//
// 1) Find the beginning of the impacted ranges in the LHS.
// 2) Create a new, merged sub-squence of ranges merging from the position in
// #1 until either LHS or RHS is exhausted. Any part of LHS between RHS
// entries being merged will be copied into this new range.
// 3) Replace the relevant section in LHS with these newly merged ranges.
// 4) Append any remaning ranges from RHS if LHS is exhausted in #2.
//
// We don't follow the typical in-place merge strategy for sorted ranges of
// appending the new ranges to the back and then using std::inplace_merge
// because one step of the merge can both mutate the original elements and
// remove elements from the original. Essentially, because the merge includes
// collapsing overlapping ranges, a more complex approach is required.
// We do an initial binary search to optimize for a common pattern: a large
// LHS, and a very small RHS.
const_iterator RI = RHS.begin(), RE = RHS.end();
iterator LE = end(), LI = std::upper_bound(begin(), LE, *RI);
// Merge into NewRanges until one of the ranges is exhausted.
SmallVector<LiveRange, 4> NewRanges;
// Keep track of where to begin the replacement.
iterator ReplaceI = LI;
// If there are preceding ranges in the LHS, put the last one into NewRanges
// so we can optionally extend it. Adjust the replacement point accordingly.
if (LI != begin()) {
ReplaceI = llvm::prior(LI);
NewRanges.push_back(*ReplaceI);
}
// Now loop over the mergable portions of both LHS and RHS, merging into
// NewRanges.
while (LI != LE && RI != RE) {
// Skip incoming ranges with the wrong value.
if (RHSValNo && RI->valno != RHSValNo) {
++RI;
continue;
}
// Select the first range. We pick the earliest start point, and then the
// largest range.
LiveRange R = *LI;
if (*RI < R) {
R = *RI;
++RI;
if (LHSValNo)
R.valno = LHSValNo;
} else {
++LI;
}
if (NewRanges.empty()) {
NewRanges.push_back(R);
continue;
}
LiveRange &LastR = NewRanges.back();
if (R.valno == LastR.valno) {
// Try to merge this range into the last one.
if (R.start <= LastR.end) {
LastR.end = std::max(LastR.end, R.end);
continue;
}
} else {
// We can't merge ranges across a value number.
assert(R.start >= LastR.end &&
"Cannot overlap two LiveRanges with differing ValID's");
}
// If all else fails, just append the range.
NewRanges.push_back(R);
}
assert(RI == RE || LI == LE);
// Check for being able to merge into the trailing sequence of ranges on the LHS.
if (!NewRanges.empty())
for (; LI != LE && (LI->valno == NewRanges.back().valno &&
LI->start <= NewRanges.back().end);
++LI)
NewRanges.back().end = std::max(NewRanges.back().end, LI->end);
// Replace the ranges in the LHS with the newly merged ones. It would be
// really nice if there were a move-supporting 'replace' directly in
// SmallVector, but as there is not, we pay the price of copies to avoid
// wasted memory allocations.
SmallVectorImpl<LiveRange>::iterator NRI = NewRanges.begin(),
NRE = NewRanges.end();
for (; ReplaceI != LI && NRI != NRE; ++ReplaceI, ++NRI)
*ReplaceI = *NRI;
if (NRI == NRE)
ranges.erase(ReplaceI, LI);
else
ranges.insert(LI, NRI, NRE);
// And finally insert any trailing end of RHS (if we have one).
for (; RI != RE; ++RI) {
LiveRange R = *RI;
if (LHSValNo)
R.valno = LHSValNo;
if (!ranges.empty() &&
ranges.back().valno == R.valno && R.start <= ranges.back().end)
ranges.back().end = std::max(ranges.back().end, R.end);
else
ranges.push_back(R);
}
// Ensure we finished with a valid new sequence of ranges.
verify();
}
/// MergeRangesInAsValue - Merge all of the intervals in RHS into this live
@ -636,7 +502,9 @@ void LiveInterval::mergeIntervalRanges(const LiveInterval &RHS,
/// the overlapping LiveRanges have the specified value number.
void LiveInterval::MergeRangesInAsValue(const LiveInterval &RHS,
VNInfo *LHSValNo) {
mergeIntervalRanges(RHS, 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 ranges of a specific val#
@ -647,7 +515,10 @@ void LiveInterval::MergeRangesInAsValue(const LiveInterval &RHS,
void LiveInterval::MergeValueInAsValue(const LiveInterval &RHS,
const VNInfo *RHSValNo,
VNInfo *LHSValNo) {
mergeIntervalRanges(RHS, LHSValNo, RHSValNo);
LiveRangeUpdater Updater(this);
for (const_iterator I = RHS.begin(), E = RHS.end(); I != E; ++I)
if (I->valno == RHSValNo)
Updater.add(I->start, I->end, LHSValNo);
}
/// MergeValueNumberInto - This method is called when two value nubmers