RPCSX/llvm
1
0
Fork 0
mirror of https://github.com/RPCSX/llvm.git synced 2025-03-03 18:37:56 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

[LV] Clean up uniform induction variable analysis (NFC)

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@281368 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Matthew Simpson 2016-09-13 19:01:45 +00:00
parent 9330005ad6
commit 470b8e4d54
1 changed files with 31 additions and 23 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

54
lib/Transforms/Vectorize/LoopVectorize.cpp
View File

@ -5434,29 +5434,37 @@ void LoopVectorizationLegality::collectLoopUniforms() {
}
// For an instruction to be added into Worklist above, all its users inside
// the current loop should be already added into Worklist. This condition
// cannot be true for phi instructions which is always in a dependence loop.
// Because any instruction in the dependence cycle always depends on others
// in the cycle to be added into Worklist first, the result is no ones in
// the cycle will be added into Worklist in the end.
// That is why we process PHI separately.
for (auto &Induction : *getInductionVars()) {
auto *PN = Induction.first;
auto *UpdateV = PN->getIncomingValueForBlock(TheLoop->getLoopLatch());
if (all_of(PN->users(),
[&](User *U) -> bool {
return U == UpdateV || isOutOfScope(U) ||
Worklist.count(cast<Instruction>(U));
}) &&
all_of(UpdateV->users(), [&](User *U) -> bool {
return U == PN || isOutOfScope(U) ||
Worklist.count(cast<Instruction>(U));
})) {
Worklist.insert(cast<Instruction>(PN));
Worklist.insert(cast<Instruction>(UpdateV));
DEBUG(dbgs() << "LV: Found uniform instruction: " << *PN << "\n");
DEBUG(dbgs() << "LV: Found uniform instruction: " << *UpdateV << "\n");
}
// the loop should also be in Worklist. However, this condition cannot be
// true for phi nodes that form a cyclic dependence. We must process phi
// nodes separately. An induction variable will remain uniform if all users
// of the induction variable and induction variable update remain uniform.
for (auto &Induction : Inductions) {
auto *Ind = Induction.first;
auto *IndUpdate = cast<Instruction>(Ind->getIncomingValueForBlock(Latch));
// Determine if all users of the induction variable are uniform after
// vectorization.
auto UniformInd = all_of(Ind->users(), [&](User *U) -> bool {
auto *I = cast<Instruction>(U);
return I == IndUpdate || !TheLoop->contains(I) || Worklist.count(I);
});
if (!UniformInd)
continue;
// Determine if all users of the induction variable update instruction are
// uniform after vectorization.
auto UniformIndUpdate = all_of(IndUpdate->users(), [&](User *U) -> bool {
auto *I = cast<Instruction>(U);
return I == Ind || !TheLoop->contains(I) || Worklist.count(I);
});
if (!UniformIndUpdate)
continue;
// The induction variable and its update instruction will remain uniform.
Worklist.insert(Ind);
Worklist.insert(IndUpdate);
DEBUG(dbgs() << "LV: Found uniform instruction: " << *Ind << "\n");
DEBUG(dbgs() << "LV: Found uniform instruction: " << *IndUpdate << "\n");
}
Uniforms.insert(Worklist.begin(), Worklist.end());