RPCS3/llvm
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm.git synced 2024-12-25 21:46:50 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Rewrite LoopRotation's SSA updating code using SSAUpdater.

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@85016 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Dan Gohman 2009-10-24 23:19:52 +00:00
parent a3f85d206a
commit e6e37b94e8
1 changed files with 64 additions and 220 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

284
lib/Transforms/Scalar/LoopRotation.cpp
View File

@ -21,6 +21,7 @@
#include "llvm/Analysis/ScalarEvolution.h" #include "llvm/Analysis/ScalarEvolution.h"
#include "llvm/Transforms/Utils/Local.h" #include "llvm/Transforms/Utils/Local.h"
#include "llvm/Transforms/Utils/BasicBlockUtils.h" #include "llvm/Transforms/Utils/BasicBlockUtils.h"
#include "llvm/Transforms/Utils/SSAUpdater.h"
#include "llvm/Support/CommandLine.h" #include "llvm/Support/CommandLine.h"
#include "llvm/Support/Debug.h" #include "llvm/Support/Debug.h"
#include "llvm/ADT/Statistic.h" #include "llvm/ADT/Statistic.h"
@ -32,16 +33,6 @@ using namespace llvm;
STATISTIC(NumRotated, "Number of loops rotated"); STATISTIC(NumRotated, "Number of loops rotated");
namespace { namespace {
class RenameData {
public:
RenameData(Instruction *O, Value *P, Instruction *H)
: Original(O), PreHeader(P), Header(H) { }
public:
Instruction *Original; // Original instruction
Value *PreHeader; // Original pre-header replacement
Instruction *Header; // New header replacement
};
class LoopRotate : public LoopPass { class LoopRotate : public LoopPass {
public: public:
static char ID; // Pass ID, replacement for typeid static char ID; // Pass ID, replacement for typeid
@ -71,25 +62,12 @@ namespace {
/// Initialize local data /// Initialize local data
void initialize(); void initialize();
/// Make sure all Exit block PHINodes have required incoming values.
/// If incoming value is constant or defined outside the loop then
/// PHINode may not have an entry for original pre-header.
void updateExitBlock();
/// Return true if this instruction is used outside original header.
bool usedOutsideOriginalHeader(Instruction *In);
/// Find Replacement information for instruction. Return NULL if it is
/// not available.
const RenameData *findReplacementData(Instruction *I);
/// After loop rotation, loop pre-header has multiple sucessors. /// After loop rotation, loop pre-header has multiple sucessors.
/// Insert one forwarding basic block to ensure that loop pre-header /// Insert one forwarding basic block to ensure that loop pre-header
/// has only one successor. /// has only one successor.
void preserveCanonicalLoopForm(LPPassManager &LPM); void preserveCanonicalLoopForm(LPPassManager &LPM);
private: private:
Loop *L; Loop *L;
BasicBlock *OrigHeader; BasicBlock *OrigHeader;
BasicBlock *OrigPreHeader; BasicBlock *OrigPreHeader;
@ -97,7 +75,6 @@ namespace {
BasicBlock *NewHeader; BasicBlock *NewHeader;
BasicBlock *Exit; BasicBlock *Exit;
LPPassManager *LPM_Ptr; LPPassManager *LPM_Ptr;
SmallVector<RenameData, MAX_HEADER_SIZE> LoopHeaderInfo;
}; };
} }
@ -199,168 +176,88 @@ bool LoopRotate::rotateLoop(Loop *Lp, LPPassManager &LPM) {
"New header doesn't have one pred!"); "New header doesn't have one pred!");
FoldSingleEntryPHINodes(NewHeader); FoldSingleEntryPHINodes(NewHeader);
// Copy PHI nodes and other instructions from the original header // Begin by walking OrigHeader and populating ValueMap with an entry for
// into the original pre-header. Unlike the original header, the original // each Instruction.
// pre-header is not a member of the loop.
//
// The new loop header is the one and only successor of original header that
// is inside the loop. All other original header successors are outside
// the loop. Copy PHI Nodes from the original header into the new loop header.
// Add second incoming value, from original loop pre-header into these phi
// nodes. If a value defined in original header is used outside original
// header then new loop header will need new phi nodes with two incoming
// values, one definition from original header and second definition is
// from original loop pre-header.
// Remove terminator from Original pre-header. Original pre-header will
// receive a clone of original header terminator as a new terminator.
OrigPreHeader->getInstList().pop_back();
BasicBlock::iterator I = OrigHeader->begin(), E = OrigHeader->end(); BasicBlock::iterator I = OrigHeader->begin(), E = OrigHeader->end();
PHINode *PN = 0; DenseMap<const Value *, Value *> ValueMap;
for (; (PN = dyn_cast<PHINode>(I)); ++I) {
// PHI nodes are not copied into original pre-header. Instead their values
// are directly propagated.
Value *NPV = PN->getIncomingValueForBlock(OrigPreHeader);
// Create a new PHI node with two incoming values for NewHeader. // For PHI nodes, the value available in OldPreHeader is just the
// One incoming value is from OrigLatch (through OrigHeader) and the // incoming value from OldPreHeader.
// second incoming value is from original pre-header. for (; PHINode *PN = dyn_cast<PHINode>(I); ++I)
PHINode *NH = PHINode::Create(PN->getType(), PN->getName(), ValueMap[PN] = PN->getIncomingValue(PN->getBasicBlockIndex(OrigPreHeader));
NewHeader->begin());
NH->addIncoming(PN->getIncomingValueForBlock(OrigLatch), OrigHeader);
NH->addIncoming(NPV, OrigPreHeader);
// "In" can be replaced by NH at various places.
LoopHeaderInfo.push_back(RenameData(PN, NPV, NH));
}
// Now, handle non-phi instructions. // For the rest of the instructions, create a clone in the OldPreHeader.
TerminatorInst *LoopEntryBranch = OrigPreHeader->getTerminator();
for (; I != E; ++I) { for (; I != E; ++I) {
Instruction *In = I; Instruction *C = I->clone();
assert(!isa<PHINode>(In) && "PHINode is not expected here"); C->setName(I->getName());
C->insertBefore(LoopEntryBranch);
// This is not a PHI instruction. Insert its clone into original pre-header. ValueMap[I] = C;
// If this instruction is using a value from same basic block then
// update it to use value from cloned instruction.
Instruction *C = In->clone();
C->setName(In->getName());
OrigPreHeader->getInstList().push_back(C);
for (unsigned opi = 0, e = In->getNumOperands(); opi != e; ++opi) {
Instruction *OpInsn = dyn_cast<Instruction>(In->getOperand(opi));
if (!OpInsn) continue; // Ignore non-instruction values.
if (const RenameData *D = findReplacementData(OpInsn))
C->setOperand(opi, D->PreHeader);
}
// If this instruction is used outside this basic block then
// create new PHINode for this instruction.
Instruction *NewHeaderReplacement = NULL;
if (usedOutsideOriginalHeader(In)) {
PHINode *PN = PHINode::Create(In->getType(), In->getName(),
NewHeader->begin());
PN->addIncoming(In, OrigHeader);
PN->addIncoming(C, OrigPreHeader);
NewHeaderReplacement = PN;
}
LoopHeaderInfo.push_back(RenameData(In, C, NewHeaderReplacement));
} }
// Rename uses of original header instructions to reflect their new // Along with all the other instructions, we just cloned OrigHeader's
// definitions (either from original pre-header node or from newly created // terminator into OrigPreHeader. Fix up the PHI nodes in each of OrigHeader's
// new header PHINodes. // successors by duplicating their incoming values for OrigHeader.
// TerminatorInst *TI = OrigHeader->getTerminator();
// Original header instructions are used in for (unsigned i = 0, e = TI->getNumSuccessors(); i != e; ++i)
// 1) Original header: for (BasicBlock::iterator BI = TI->getSuccessor(i)->begin();
// PHINode *PN = dyn_cast<PHINode>(BI); ++BI)
// If instruction is used in non-phi instructions then it is using PN->addIncoming(PN->getIncomingValueForBlock(OrigHeader), OrigPreHeader);
// defintion from original heder iteself. Do not replace this use
// with definition from new header or original pre-header.
//
// If instruction is used in phi node then it is an incoming
// value. Rename its use to reflect new definition from new-preheader
// or new header.
//
// 2) Inside loop but not in original header
//
// Replace this use to reflect definition from new header.
for (unsigned LHI = 0, LHI_E = LoopHeaderInfo.size(); LHI != LHI_E; ++LHI) {
const RenameData &ILoopHeaderInfo = LoopHeaderInfo[LHI];
if (!ILoopHeaderInfo.Header) // Now that OrigPreHeader has a clone of OrigHeader's terminator, remove
continue; // OrigPreHeader's old terminator (the original branch into the loop), and
// remove the corresponding incoming values from the PHI nodes in OrigHeader.
LoopEntryBranch->eraseFromParent();
for (I = OrigHeader->begin(); PHINode *PN = dyn_cast<PHINode>(I); ++I)
PN->removeIncomingValue(PN->getBasicBlockIndex(OrigPreHeader));
Instruction *OldPhi = ILoopHeaderInfo.Original; // Now fix up users of the instructions in OrigHeader, insertting PHI nodes
Instruction *NewPhi = ILoopHeaderInfo.Header; // as necessary.
SSAUpdater SSA;
for (I = OrigHeader->begin(); I != E; ++I) {
Value *OrigHeaderVal = I;
Value *OrigPreHeaderVal = ValueMap[OrigHeaderVal];
// Before replacing uses, collect them first, so that iterator is // The value now exits in two versions: the initial value in the preheader
// not invalidated. // and the loop "next" value in the original header.
SmallVector<Instruction *, 16> AllUses; SSA.Initialize(OrigHeaderVal);
for (Value::use_iterator UI = OldPhi->use_begin(), UE = OldPhi->use_end(); SSA.AddAvailableValue(OrigHeader, OrigHeaderVal);
UI != UE; ++UI) SSA.AddAvailableValue(OrigPreHeader, OrigPreHeaderVal);
AllUses.push_back(cast<Instruction>(UI));
for (SmallVector<Instruction *, 16>::iterator UI = AllUses.begin(), // Visit each use of the OrigHeader instruction.
UE = AllUses.end(); UI != UE; ++UI) { for (Value::use_iterator UI = OrigHeaderVal->use_begin(),
Instruction *U = *UI; UE = OrigHeaderVal->use_end(); UI != UE; ) {
BasicBlock *Parent = U->getParent(); // Grab the use before incrementing the iterator.
Use &U = UI.getUse();
// Used inside original header // Increment the iterator before removing the use from the list.
if (Parent == OrigHeader) { ++UI;
// Do not rename uses inside original header non-phi instructions.
PHINode *PU = dyn_cast<PHINode>(U); // SSAUpdater can't handle a non-PHI use in the same block as an
if (!PU) // earlier def. We can easily handle those cases manually.
Instruction *UserInst = cast<Instruction>(U.getUser());
if (!isa<PHINode>(UserInst)) {
BasicBlock *UserBB = UserInst->getParent();
// The original users in the OrigHeader are already using the
// original definitions.
if (UserBB == OrigHeader)
continue; continue;
// Do not rename uses inside original header phi nodes, if the // Users in the OrigPreHeader need to use the value to which the
// incoming value is for new header. // original definitions are mapped.
if (PU->getBasicBlockIndex(NewHeader) != -1 if (UserBB == OrigPreHeader) {
&& PU->getIncomingValueForBlock(NewHeader) == U) U = OrigPreHeaderVal;
continue; continue;
}
U->replaceUsesOfWith(OldPhi, NewPhi);
continue;
} }
// Used inside loop, but not in original header. // Anything else can be handled by SSAUpdater.
if (L->contains(U->getParent())) { SSA.RewriteUse(U);
if (U != NewPhi)
U->replaceUsesOfWith(OldPhi, NewPhi);
continue;
}
// Used inside Exit Block. Since we are in LCSSA form, U must be PHINode.
if (U->getParent() == Exit) {
assert(isa<PHINode>(U) && "Use in Exit Block that is not PHINode");
PHINode *UPhi = cast<PHINode>(U);
// UPhi already has one incoming argument from original header.
// Add second incoming argument from new Pre header.
UPhi->addIncoming(ILoopHeaderInfo.PreHeader, OrigPreHeader);
} else {
// Used outside Exit block. Create a new PHI node in the exit block
// to receive the value from the new header and pre-header.
PHINode *PN = PHINode::Create(U->getType(), U->getName(),
Exit->begin());
PN->addIncoming(ILoopHeaderInfo.PreHeader, OrigPreHeader);
PN->addIncoming(OldPhi, OrigHeader);
U->replaceUsesOfWith(OldPhi, PN);
}
} }
} }
/// Make sure all Exit block PHINodes have required incoming values.
updateExitBlock();
// Update CFG // NewHeader is now the header of the loop.
// Removing incoming branch from loop preheader to original header.
// Now original header is inside the loop.
for (BasicBlock::iterator I = OrigHeader->begin();
(PN = dyn_cast<PHINode>(I)); ++I)
PN->removeIncomingValue(OrigPreHeader);
// Make NewHeader as the new header for the loop.
L->moveToHeader(NewHeader); L->moveToHeader(NewHeader);
preserveCanonicalLoopForm(LPM); preserveCanonicalLoopForm(LPM);
@ -369,31 +266,6 @@ bool LoopRotate::rotateLoop(Loop *Lp, LPPassManager &LPM) {
return true; return true;
} }
/// Make sure all Exit block PHINodes have required incoming values.
/// If an incoming value is constant or defined outside the loop then
/// PHINode may not have an entry for the original pre-header.
void LoopRotate::updateExitBlock() {
PHINode *PN;
for (BasicBlock::iterator I = Exit->begin();
(PN = dyn_cast<PHINode>(I)); ++I) {
// There is already one incoming value from original pre-header block.
if (PN->getBasicBlockIndex(OrigPreHeader) != -1)
continue;
const RenameData *ILoopHeaderInfo;
Value *V = PN->getIncomingValueForBlock(OrigHeader);
if (isa<Instruction>(V) &&
(ILoopHeaderInfo = findReplacementData(cast<Instruction>(V)))) {
assert(ILoopHeaderInfo->PreHeader && "Missing New Preheader Instruction");
PN->addIncoming(ILoopHeaderInfo->PreHeader, OrigPreHeader);
} else {
PN->addIncoming(V, OrigPreHeader);
}
}
}
/// Initialize local data /// Initialize local data
void LoopRotate::initialize() { void LoopRotate::initialize() {
L = NULL; L = NULL;
@ -401,34 +273,6 @@ void LoopRotate::initialize() {
OrigPreHeader = NULL; OrigPreHeader = NULL;
NewHeader = NULL; NewHeader = NULL;
Exit = NULL; Exit = NULL;
LoopHeaderInfo.clear();
}
/// Return true if this instruction is used by any instructions in the loop that
/// aren't in original header.
bool LoopRotate::usedOutsideOriginalHeader(Instruction *In) {
for (Value::use_iterator UI = In->use_begin(), UE = In->use_end();
UI != UE; ++UI) {
BasicBlock *UserBB = cast<Instruction>(UI)->getParent();
if (UserBB != OrigHeader && L->contains(UserBB))
return true;
}
return false;
}
/// Find Replacement information for instruction. Return NULL if it is
/// not available.
const RenameData *LoopRotate::findReplacementData(Instruction *In) {
// Since LoopHeaderInfo is small, linear walk is OK.
for (unsigned LHI = 0, LHI_E = LoopHeaderInfo.size(); LHI != LHI_E; ++LHI) {
const RenameData &ILoopHeaderInfo = LoopHeaderInfo[LHI];
if (ILoopHeaderInfo.Original == In)
return &ILoopHeaderInfo;
}
return NULL;
} }
/// After loop rotation, loop pre-header has multiple sucessors. /// After loop rotation, loop pre-header has multiple sucessors.