RPCSX/llvm
1
0
Fork 0
mirror of https://github.com/RPCSX/llvm.git synced 2025-04-11 04:30:52 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

LoopInterchange: Rephrase instruction moving using ilist's splice and factor it into a function

Browse Source 
+ Random cleanups. No functional change.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@231501 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Benjamin Kramer 2015-03-06 18:59:14 +00:00
parent ae6bbac733
commit 78588257de
1 changed files with 19 additions and 56 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

75
lib/Transforms/Scalar/LoopInterchange.cpp
View File

@ -545,9 +545,7 @@ struct LoopInterchange : public FunctionPass {
if (!Interchanged) if (!Interchanged)
return Changed; return Changed;
// Loops interchanged reflect the same in LoopList // Loops interchanged reflect the same in LoopList
Loop *OldOuterLoop = LoopList[i - 1]; std::swap(LoopList[i - 1], LoopList[i]);
LoopList[i - 1] = LoopList[i];
LoopList[i] = OldOuterLoop;
// Update the DependencyMatrix // Update the DependencyMatrix
interChangeDepedencies(DependencyMatrix, i, i - 1); interChangeDepedencies(DependencyMatrix, i, i - 1);
@ -974,18 +972,10 @@ bool LoopInterchangeTransform::transform() {
void LoopInterchangeTransform::initialize() {} void LoopInterchangeTransform::initialize() {}
void LoopInterchangeTransform::splitInnerLoopLatch(Instruction *inc) { void LoopInterchangeTransform::splitInnerLoopLatch(Instruction *Inc) {
BasicBlock *InnerLoopLatch = InnerLoop->getLoopLatch(); BasicBlock *InnerLoopLatch = InnerLoop->getLoopLatch();
BasicBlock::iterator I = InnerLoopLatch->begin();
BasicBlock::iterator E = InnerLoopLatch->end();
for (; I != E; ++I) {
if (inc == I)
break;
}
BasicBlock *InnerLoopLatchPred = InnerLoopLatch; BasicBlock *InnerLoopLatchPred = InnerLoopLatch;
InnerLoopLatch = SplitBlock(InnerLoopLatchPred, I, DT, LI); InnerLoopLatch = SplitBlock(InnerLoopLatchPred, Inc, DT, LI);
} }
void LoopInterchangeTransform::splitOuterLoopLatch() { void LoopInterchangeTransform::splitOuterLoopLatch() {
@ -1005,38 +995,28 @@ void LoopInterchangeTransform::splitInnerLoopHeader() {
"InnerLoopHeader \n"); "InnerLoopHeader \n");
} }
/// \brief Move all instructions except the terminator from FromBB right before
/// InsertBefore
static void moveBBContents(BasicBlock *FromBB, Instruction *InsertBefore) {
auto &ToList = InsertBefore->getParent()->getInstList();
auto &FromList = FromBB->getInstList();
ToList.splice(InsertBefore, FromList, FromList.begin(),
FromBB->getTerminator());
}
void LoopInterchangeTransform::adjustOuterLoopPreheader() { void LoopInterchangeTransform::adjustOuterLoopPreheader() {
BasicBlock *OuterLoopPreHeader = OuterLoop->getLoopPreheader(); BasicBlock *OuterLoopPreHeader = OuterLoop->getLoopPreheader();
SmallVector<Instruction *, 8> Inst;
for (auto I = OuterLoopPreHeader->begin(), E = OuterLoopPreHeader->end();
I != E; ++I) {
if (isa<BranchInst>(*I))
break;
Inst.push_back(I);
}
BasicBlock *InnerPreHeader = InnerLoop->getLoopPreheader(); BasicBlock *InnerPreHeader = InnerLoop->getLoopPreheader();
for (auto I = Inst.begin(), E = Inst.end(); I != E; ++I) {
Instruction *Ins = cast<Instruction>(*I); moveBBContents(OuterLoopPreHeader, InnerPreHeader->getTerminator());
Ins->moveBefore(InnerPreHeader->getTerminator());
}
} }
void LoopInterchangeTransform::adjustInnerLoopPreheader() { void LoopInterchangeTransform::adjustInnerLoopPreheader() {
BasicBlock *InnerLoopPreHeader = InnerLoop->getLoopPreheader(); BasicBlock *InnerLoopPreHeader = InnerLoop->getLoopPreheader();
SmallVector<Instruction *, 8> Inst;
for (auto I = InnerLoopPreHeader->begin(), E = InnerLoopPreHeader->end();
I != E; ++I) {
if (isa<BranchInst>(*I))
break;
Inst.push_back(I);
}
BasicBlock *OuterHeader = OuterLoop->getHeader(); BasicBlock *OuterHeader = OuterLoop->getHeader();
for (auto I = Inst.begin(), E = Inst.end(); I != E; ++I) {
Instruction *Ins = cast<Instruction>(*I); moveBBContents(InnerLoopPreHeader, OuterHeader->getTerminator());
Ins->moveBefore(OuterHeader->getTerminator());
}
} }
bool LoopInterchangeTransform::adjustLoopBranches() { bool LoopInterchangeTransform::adjustLoopBranches() {
@ -1141,32 +1121,15 @@ void LoopInterchangeTransform::adjustLoopPreheaders() {
BranchInst *InnerTermBI = BranchInst *InnerTermBI =
cast<BranchInst>(InnerLoopPreHeader->getTerminator()); cast<BranchInst>(InnerLoopPreHeader->getTerminator());
SmallVector<Value *, 16> OuterPreheaderInstr;
SmallVector<Value *, 16> InnerPreheaderInstr;
for (auto I = OuterLoopPreHeader->begin(); !isa<BranchInst>(I); ++I)
OuterPreheaderInstr.push_back(I);
for (auto I = InnerLoopPreHeader->begin(); !isa<BranchInst>(I); ++I)
InnerPreheaderInstr.push_back(I);
BasicBlock *HeaderSplit = BasicBlock *HeaderSplit =
SplitBlock(OuterLoopHeader, OuterLoopHeader->getTerminator(), DT, LI); SplitBlock(OuterLoopHeader, OuterLoopHeader->getTerminator(), DT, LI);
Instruction *InsPoint = HeaderSplit->getFirstNonPHI(); Instruction *InsPoint = HeaderSplit->getFirstNonPHI();
// These instructions should now be executed inside the loop. // These instructions should now be executed inside the loop.
// Move instruction into a new block after outer header. // Move instruction into a new block after outer header.
for (auto I = InnerPreheaderInstr.begin(), E = InnerPreheaderInstr.end(); moveBBContents(InnerLoopPreHeader, InsPoint);
I != E; ++I) {
Instruction *Ins = cast<Instruction>(*I);
Ins->moveBefore(InsPoint);
}
// These instructions were not executed previously in the loop so move them to // These instructions were not executed previously in the loop so move them to
// the older inner loop preheader. // the older inner loop preheader.
for (auto I = OuterPreheaderInstr.begin(), E = OuterPreheaderInstr.end(); moveBBContents(OuterLoopPreHeader, InnerTermBI);
I != E; ++I) {
Instruction *Ins = cast<Instruction>(*I);
Ins->moveBefore(InnerTermBI);
}
} }
bool LoopInterchangeTransform::adjustLoopLinks() { bool LoopInterchangeTransform::adjustLoopLinks() {