6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2025-09-27 16:17:17 +00:00
Code Issues Projects Releases Wiki Activity

Revert all my SSAUpdater patches. The PHI placement algorithm is not correct

Browse Source 
(what was I thinking?) and there's also a problem with LCSSA.  I'll try again
later with fixes.

--- Reverse-merging r100263 into '.':
U    lib/Transforms/Utils/SSAUpdater.cpp
--- Reverse-merging r100177 into '.':
G    lib/Transforms/Utils/SSAUpdater.cpp
--- Reverse-merging r100148 into '.':
G    lib/Transforms/Utils/SSAUpdater.cpp
--- Reverse-merging r100147 into '.':
U    include/llvm/Transforms/Utils/SSAUpdater.h
G    lib/Transforms/Utils/SSAUpdater.cpp
--- Reverse-merging r100131 into '.':
G    include/llvm/Transforms/Utils/SSAUpdater.h
G    lib/Transforms/Utils/SSAUpdater.cpp
--- Reverse-merging r100130 into '.':
G    lib/Transforms/Utils/SSAUpdater.cpp
--- Reverse-merging r100126 into '.':
G    include/llvm/Transforms/Utils/SSAUpdater.h
G    lib/Transforms/Utils/SSAUpdater.cpp
--- Reverse-merging r100050 into '.':
D    test/Transforms/GVN/2010-03-31-RedundantPHIs.ll
--- Reverse-merging r100047 into '.':
G    include/llvm/Transforms/Utils/SSAUpdater.h
G    lib/Transforms/Utils/SSAUpdater.cpp


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@100264 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Bob Wilson
2010-04-03 03:50:38 +00:00
parent 4cc3c26834
commit 49c283fd3f
3 changed files with 195 additions and 387 deletions
Download Patch File Download Diff File Expand all files Collapse all files

32
include/llvm/Transforms/Utils/SSAUpdater.h
View File

@@ -27,28 +27,22 @@ namespace llvm {
/// transformation wants to rewrite a set of uses of one value with uses of a /// transformation wants to rewrite a set of uses of one value with uses of a
/// set of values. /// set of values.
class SSAUpdater { class SSAUpdater {
public:
class BBInfo;
private:
/// AvailableVals - This keeps track of which value to use on a per-block /// AvailableVals - This keeps track of which value to use on a per-block
/// basis. When we insert PHI nodes, we keep track of them here. /// basis. When we insert PHI nodes, we keep track of them here. We use
//typedef DenseMap<BasicBlock*, Value*> AvailableValsTy; /// TrackingVH's for the value of the map because we RAUW PHI nodes when we
/// eliminate them, and want the TrackingVH's to track this.
//typedef DenseMap<BasicBlock*, TrackingVH<Value> > AvailableValsTy;
void *AV; void *AV;
/// PrototypeValue is an arbitrary representative value, which we derive names /// PrototypeValue is an arbitrary representative value, which we derive names
/// and a type for PHI nodes. /// and a type for PHI nodes.
Value *PrototypeValue; Value *PrototypeValue;
/// BBMap - The GetValueAtEndOfBlock method maintains this mapping from /// IncomingPredInfo - We use this as scratch space when doing our recursive
/// basic blocks to BBInfo structures. /// walk. This should only be used in GetValueInBlockInternal, normally it
/// typedef DenseMap<BasicBlock*, BBInfo*> BBMapTy; /// should be empty.
void *BM; //std::vector<std::pair<BasicBlock*, TrackingVH<Value> > > IncomingPredInfo;
void *IPI;
/// Allocator - The GetValueAtEndOfBlock method uses this BumpPtrAllocator to
/// hold its internal data. The allocator and its storage is created and
/// discarded for each invocation of GetValueAtEndOfBlock.
void *BPA;
/// InsertedPHIs - If this is non-null, the SSAUpdater adds all PHI nodes that /// InsertedPHIs - If this is non-null, the SSAUpdater adds all PHI nodes that
/// it creates to the vector. /// it creates to the vector.
@@ -105,14 +99,6 @@ public:
private: private:
Value *GetValueAtEndOfBlockInternal(BasicBlock *BB); Value *GetValueAtEndOfBlockInternal(BasicBlock *BB);
void FindPHIPlacement(BasicBlock *BB, BBInfo *Info, bool &Changed,
unsigned Counter);
void FindAvailableVal(BasicBlock *BB, BBInfo *Info, unsigned Counter);
void FindExistingPHI(BasicBlock *BB);
bool CheckIfPHIMatches(PHINode *PHI);
void RecordMatchingPHI(PHINode *PHI);
void ClearPHITags(PHINode *PHI);
void operator=(const SSAUpdater&); // DO NOT IMPLEMENT void operator=(const SSAUpdater&); // DO NOT IMPLEMENT
SSAUpdater(const SSAUpdater&); // DO NOT IMPLEMENT SSAUpdater(const SSAUpdater&); // DO NOT IMPLEMENT
}; };

504
lib/Transforms/Utils/SSAUpdater.cpp
View File

@@ -11,86 +11,34 @@
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#define DEBUG_TYPE "ssaupdater"
#include "llvm/Transforms/Utils/SSAUpdater.h" #include "llvm/Transforms/Utils/SSAUpdater.h"
#include "llvm/Instructions.h" #include "llvm/Instructions.h"
#include "llvm/ADT/DenseMap.h" #include "llvm/ADT/DenseMap.h"
#include "llvm/Support/AlignOf.h"
#include "llvm/Support/Allocator.h"
#include "llvm/Support/CFG.h" #include "llvm/Support/CFG.h"
#include "llvm/Support/Debug.h" #include "llvm/Support/Debug.h"
#include "llvm/Support/ValueHandle.h"
#include "llvm/Support/raw_ostream.h" #include "llvm/Support/raw_ostream.h"
using namespace llvm; using namespace llvm;
/// BBInfo - Per-basic block information used internally by SSAUpdater. typedef DenseMap<BasicBlock*, TrackingVH<Value> > AvailableValsTy;
/// The predecessors of each block are cached here since pred_iterator is typedef std::vector<std::pair<BasicBlock*, TrackingVH<Value> > >
/// slow and we need to iterate over the blocks at least a few times. IncomingPredInfoTy;
class SSAUpdater::BBInfo {
public:
Value *AvailableVal; // Value to use in this block.
BasicBlock *DefBB; // Block that defines the available value.
unsigned NumPreds; // Number of predecessor blocks.
BasicBlock **Preds; // Array[NumPreds] of predecessor blocks.
unsigned Counter; // Marker to identify blocks already visited.
PHINode *PHITag; // Marker for existing PHIs that match.
BBInfo(BasicBlock *BB, Value *V, BumpPtrAllocator *Allocator);
};
typedef DenseMap<BasicBlock*, SSAUpdater::BBInfo*> BBMapTy;
SSAUpdater::BBInfo::BBInfo(BasicBlock *BB, Value *V,
BumpPtrAllocator *Allocator)
: AvailableVal(V), DefBB(0), NumPreds(0), Preds(0), Counter(0), PHITag(0) {
// If this block has a known value, don't bother finding its predecessors.
if (V) {
DefBB = BB;
return;
}
// We can get our predecessor info by walking the pred_iterator list, but it
// is relatively slow. If we already have PHI nodes in this block, walk one
// of them to get the predecessor list instead.
if (PHINode *SomePhi = dyn_cast<PHINode>(BB->begin())) {
NumPreds = SomePhi->getNumIncomingValues();
Preds = static_cast<BasicBlock**>
(Allocator->Allocate(NumPreds * sizeof(BasicBlock*),
AlignOf<BasicBlock*>::Alignment));
for (unsigned pi = 0; pi != NumPreds; ++pi)
Preds[pi] = SomePhi->getIncomingBlock(pi);
return;
}
// Stash the predecessors in a temporary vector until we know how much space
// to allocate for them.
SmallVector<BasicBlock*, 10> TmpPreds;
for (pred_iterator PI = pred_begin(BB), E = pred_end(BB); PI != E; ++PI) {
TmpPreds.push_back(*PI);
++NumPreds;
}
Preds = static_cast<BasicBlock**>
(Allocator->Allocate(NumPreds * sizeof(BasicBlock*),
AlignOf<BasicBlock*>::Alignment));
memcpy(Preds, TmpPreds.data(), NumPreds * sizeof(BasicBlock*));
}
typedef DenseMap<BasicBlock*, Value*> AvailableValsTy;
static AvailableValsTy &getAvailableVals(void *AV) { static AvailableValsTy &getAvailableVals(void *AV) {
return *static_cast<AvailableValsTy*>(AV); return *static_cast<AvailableValsTy*>(AV);
} }
static BBMapTy *getBBMap(void *BM) { static IncomingPredInfoTy &getIncomingPredInfo(void *IPI) {
return static_cast<BBMapTy*>(BM); return *static_cast<IncomingPredInfoTy*>(IPI);
} }
static BumpPtrAllocator *getAllocator(void *BPA) {
return static_cast<BumpPtrAllocator*>(BPA);
}
SSAUpdater::SSAUpdater(SmallVectorImpl<PHINode*> *NewPHI) SSAUpdater::SSAUpdater(SmallVectorImpl<PHINode*> *NewPHI)
: AV(0), PrototypeValue(0), BM(0), BPA(0), InsertedPHIs(NewPHI) {} : AV(0), PrototypeValue(0), IPI(0), InsertedPHIs(NewPHI) {}
SSAUpdater::~SSAUpdater() { SSAUpdater::~SSAUpdater() {
delete &getAvailableVals(AV); delete &getAvailableVals(AV);
delete &getIncomingPredInfo(IPI);
} }
/// Initialize - Reset this object to get ready for a new set of SSA /// Initialize - Reset this object to get ready for a new set of SSA
@@ -100,6 +48,11 @@ void SSAUpdater::Initialize(Value *ProtoValue) {
AV = new AvailableValsTy(); AV = new AvailableValsTy();
else else
getAvailableVals(AV).clear(); getAvailableVals(AV).clear();
if (IPI == 0)
IPI = new IncomingPredInfoTy();
else
getIncomingPredInfo(IPI).clear();
PrototypeValue = ProtoValue; PrototypeValue = ProtoValue;
} }
@@ -120,7 +73,7 @@ void SSAUpdater::AddAvailableValue(BasicBlock *BB, Value *V) {
/// IsEquivalentPHI - Check if PHI has the same incoming value as specified /// IsEquivalentPHI - Check if PHI has the same incoming value as specified
/// in ValueMapping for each predecessor block. /// in ValueMapping for each predecessor block.
static bool IsEquivalentPHI(PHINode *PHI, static bool IsEquivalentPHI(PHINode *PHI,
DenseMap<BasicBlock*, Value*> &ValueMapping) { DenseMap<BasicBlock*, Value*> &ValueMapping) {
unsigned PHINumValues = PHI->getNumIncomingValues(); unsigned PHINumValues = PHI->getNumIncomingValues();
if (PHINumValues != ValueMapping.size()) if (PHINumValues != ValueMapping.size())
@@ -136,12 +89,38 @@ static bool IsEquivalentPHI(PHINode *PHI,
return true; return true;
} }
/// GetExistingPHI - Check if BB already contains a phi node that is equivalent
/// to the specified mapping from predecessor blocks to incoming values.
static Value *GetExistingPHI(BasicBlock *BB,
DenseMap<BasicBlock*, Value*> &ValueMapping) {
PHINode *SomePHI;
for (BasicBlock::iterator It = BB->begin();
(SomePHI = dyn_cast<PHINode>(It)); ++It) {
if (IsEquivalentPHI(SomePHI, ValueMapping))
return SomePHI;
}
return 0;
}
/// GetExistingPHI - Check if BB already contains an equivalent phi node.
/// The InputIt type must be an iterator over std::pair<BasicBlock*, Value*>
/// objects that specify the mapping from predecessor blocks to incoming values.
template<typename InputIt>
static Value *GetExistingPHI(BasicBlock *BB, const InputIt &I,
const InputIt &E) {
// Avoid create the mapping if BB has no phi nodes at all.
if (!isa<PHINode>(BB->begin()))
return 0;
DenseMap<BasicBlock*, Value*> ValueMapping(I, E);
return GetExistingPHI(BB, ValueMapping);
}
/// GetValueAtEndOfBlock - Construct SSA form, materializing a value that is /// GetValueAtEndOfBlock - Construct SSA form, materializing a value that is
/// live at the end of the specified block. /// live at the end of the specified block.
Value *SSAUpdater::GetValueAtEndOfBlock(BasicBlock *BB) { Value *SSAUpdater::GetValueAtEndOfBlock(BasicBlock *BB) {
assert(BM == 0 && BPA == 0 && "Unexpected Internal State"); assert(getIncomingPredInfo(IPI).empty() && "Unexpected Internal State");
Value *Res = GetValueAtEndOfBlockInternal(BB); Value *Res = GetValueAtEndOfBlockInternal(BB);
assert(BM == 0 && BPA == 0 && "Unexpected Internal State"); assert(getIncomingPredInfo(IPI).empty() && "Unexpected Internal State");
return Res; return Res;
} }
@@ -167,7 +146,7 @@ Value *SSAUpdater::GetValueAtEndOfBlock(BasicBlock *BB) {
Value *SSAUpdater::GetValueInMiddleOfBlock(BasicBlock *BB) { Value *SSAUpdater::GetValueInMiddleOfBlock(BasicBlock *BB) {
// If there is no definition of the renamed variable in this block, just use // If there is no definition of the renamed variable in this block, just use
// GetValueAtEndOfBlock to do our work. // GetValueAtEndOfBlock to do our work.
if (!HasValueForBlock(BB)) if (!getAvailableVals(AV).count(BB))
return GetValueAtEndOfBlock(BB); return GetValueAtEndOfBlock(BB);
// Otherwise, we have the hard case. Get the live-in values for each // Otherwise, we have the hard case. Get the live-in values for each
@@ -214,18 +193,10 @@ Value *SSAUpdater::GetValueInMiddleOfBlock(BasicBlock *BB) {
if (SingularValue != 0) if (SingularValue != 0)
return SingularValue; return SingularValue;
// Otherwise, we do need a PHI: check to see if we already have one available // Otherwise, we do need a PHI.
// in this block that produces the right value. if (Value *ExistingPHI = GetExistingPHI(BB, PredValues.begin(),
if (isa<PHINode>(BB->begin())) { PredValues.end()))
DenseMap<BasicBlock*, Value*> ValueMapping(PredValues.begin(), return ExistingPHI;
PredValues.end());
PHINode *SomePHI;
for (BasicBlock::iterator It = BB->begin();
(SomePHI = dyn_cast<PHINode>(It)); ++It) {
if (IsEquivalentPHI(SomePHI, ValueMapping))
return SomePHI;
}
}
// Ok, we have no way out, insert a new one now. // Ok, we have no way out, insert a new one now.
PHINode *InsertedPHI = PHINode::Create(PrototypeValue->getType(), PHINode *InsertedPHI = PHINode::Create(PrototypeValue->getType(),
@@ -255,7 +226,7 @@ Value *SSAUpdater::GetValueInMiddleOfBlock(BasicBlock *BB) {
/// which use their value in the corresponding predecessor. /// which use their value in the corresponding predecessor.
void SSAUpdater::RewriteUse(Use &U) { void SSAUpdater::RewriteUse(Use &U) {
Instruction *User = cast<Instruction>(U.getUser()); Instruction *User = cast<Instruction>(U.getUser());
Value *V; Value *V;
if (PHINode *UserPN = dyn_cast<PHINode>(User)) if (PHINode *UserPN = dyn_cast<PHINode>(User))
V = GetValueAtEndOfBlock(UserPN->getIncomingBlock(U)); V = GetValueAtEndOfBlock(UserPN->getIncomingBlock(U));
@@ -265,264 +236,161 @@ void SSAUpdater::RewriteUse(Use &U) {
U.set(V); U.set(V);
} }
/// GetValueAtEndOfBlockInternal - Check to see if AvailableVals has an entry /// GetValueAtEndOfBlockInternal - Check to see if AvailableVals has an entry
/// for the specified BB and if so, return it. If not, construct SSA form by /// for the specified BB and if so, return it. If not, construct SSA form by
/// first calculating the required placement of PHIs and then inserting new /// walking predecessors inserting PHI nodes as needed until we get to a block
/// PHIs where needed. /// where the value is available.
///
Value *SSAUpdater::GetValueAtEndOfBlockInternal(BasicBlock *BB) { Value *SSAUpdater::GetValueAtEndOfBlockInternal(BasicBlock *BB) {
AvailableValsTy &AvailableVals = getAvailableVals(AV); AvailableValsTy &AvailableVals = getAvailableVals(AV);
if (Value *V = AvailableVals[BB])
return V;
// Pool allocation used internally by GetValueAtEndOfBlock. // Query AvailableVals by doing an insertion of null.
BumpPtrAllocator AllocatorObj; std::pair<AvailableValsTy::iterator, bool> InsertRes =
BBMapTy BBMapObj; AvailableVals.insert(std::make_pair(BB, TrackingVH<Value>()));
BPA = &AllocatorObj;
BM = &BBMapObj;
BBInfo *Info = new (AllocatorObj) BBInfo(BB, 0, &AllocatorObj); // Handle the case when the insertion fails because we have already seen BB.
BBMapObj[BB] = Info; if (!InsertRes.second) {
// If the insertion failed, there are two cases. The first case is that the
// value is already available for the specified block. If we get this, just
// return the value.
if (InsertRes.first->second != 0)
return InsertRes.first->second;
bool Changed; // Otherwise, if the value we find is null, then this is the value is not
unsigned Counter = 1; // known but it is being computed elsewhere in our recursion. This means
do { // that we have a cycle. Handle this by inserting a PHI node and returning
Changed = false; // it. When we get back to the first instance of the recursion we will fill
FindPHIPlacement(BB, Info, Changed, Counter); // in the PHI node.
++Counter; return InsertRes.first->second =
} while (Changed); PHINode::Create(PrototypeValue->getType(), PrototypeValue->getName(),
&BB->front());
FindAvailableVal(BB, Info, Counter);
BPA = 0;
BM = 0;
return Info->AvailableVal;
}
/// FindPHIPlacement - Recursively visit the predecessors of a block to find
/// the reaching definition for each predecessor and then determine whether
/// a PHI is needed in this block.
void SSAUpdater::FindPHIPlacement(BasicBlock *BB, BBInfo *Info, bool &Changed,
unsigned Counter) {
AvailableValsTy &AvailableVals = getAvailableVals(AV);
BBMapTy *BBMap = getBBMap(BM);
BumpPtrAllocator *Allocator = getAllocator(BPA);
bool BBNeedsPHI = false;
BasicBlock *SamePredDefBB = 0;
// If there are no predecessors, then we must have found an unreachable
// block. Treat it as a definition with 'undef'.
if (Info->NumPreds == 0) {
Info->AvailableVal = UndefValue::get(PrototypeValue->getType());
Info->DefBB = BB;
return;
} }
Info->Counter = Counter; // Okay, the value isn't in the map and we just inserted a null in the entry
for (unsigned pi = 0; pi != Info->NumPreds; ++pi) { // to indicate that we're processing the block. Since we have no idea what
BasicBlock *Pred = Info->Preds[pi]; // value is in this block, we have to recurse through our predecessors.
BBMapTy::value_type &BBMapBucket = BBMap->FindAndConstruct(Pred); //
if (!BBMapBucket.second) { // While we're walking our predecessors, we keep track of them in a vector,
Value *PredVal = AvailableVals.lookup(Pred); // then insert a PHI node in the end if we actually need one. We could use a
BBMapBucket.second = new (*Allocator) BBInfo(Pred, PredVal, Allocator); // smallvector here, but that would take a lot of stack space for every level
// of the recursion, just use IncomingPredInfo as an explicit stack.
IncomingPredInfoTy &IncomingPredInfo = getIncomingPredInfo(IPI);
unsigned FirstPredInfoEntry = IncomingPredInfo.size();
// As we're walking the predecessors, keep track of whether they are all
// producing the same value. If so, this value will capture it, if not, it
// will get reset to null. We distinguish the no-predecessor case explicitly
// below.
TrackingVH<Value> ExistingValue;
// We can get our predecessor info by walking the pred_iterator list, but it
// is relatively slow. If we already have PHI nodes in this block, walk one
// of them to get the predecessor list instead.
if (PHINode *SomePhi = dyn_cast<PHINode>(BB->begin())) {
for (unsigned i = 0, e = SomePhi->getNumIncomingValues(); i != e; ++i) {
BasicBlock *PredBB = SomePhi->getIncomingBlock(i);
Value *PredVal = GetValueAtEndOfBlockInternal(PredBB);
IncomingPredInfo.push_back(std::make_pair(PredBB, PredVal));
// Set ExistingValue to singular value from all predecessors so far.
if (i == 0)
ExistingValue = PredVal;
else if (PredVal != ExistingValue)
ExistingValue = 0;
} }
BBInfo *PredInfo = BBMapBucket.second; } else {
BasicBlock *DefBB = 0; bool isFirstPred = true;
if (!PredInfo->AvailableVal) { for (pred_iterator PI = pred_begin(BB), E = pred_end(BB); PI != E; ++PI) {
if (PredInfo->Counter != Counter) BasicBlock *PredBB = *PI;
FindPHIPlacement(Pred, PredInfo, Changed, Counter); Value *PredVal = GetValueAtEndOfBlockInternal(PredBB);
IncomingPredInfo.push_back(std::make_pair(PredBB, PredVal));
// Ignore back edges where the value is not yet known. // Set ExistingValue to singular value from all predecessors so far.
if (!PredInfo->DefBB) if (isFirstPred) {
continue; ExistingValue = PredVal;
} isFirstPred = false;
DefBB = PredInfo->DefBB; } else if (PredVal != ExistingValue)
ExistingValue = 0;
if (!SamePredDefBB)
SamePredDefBB = DefBB;
else if (DefBB != SamePredDefBB)
BBNeedsPHI = true;
}
BasicBlock *NewDefBB = (BBNeedsPHI ? BB : SamePredDefBB);
if (Info->DefBB != NewDefBB) {
Changed = true;
Info->DefBB = NewDefBB;
}
}
/// FindAvailableVal - If this block requires a PHI, first check if an existing
/// PHI matches the PHI placement and reaching definitions computed earlier,
/// and if not, create a new PHI. Visit all the block's predecessors to
/// calculate the available value for each one and fill in the incoming values
/// for a new PHI.
void SSAUpdater::FindAvailableVal(BasicBlock *BB, BBInfo *Info,
unsigned Counter) {
if (Info->AvailableVal || Info->Counter == Counter)
return;
AvailableValsTy &AvailableVals = getAvailableVals(AV);
BBMapTy *BBMap = getBBMap(BM);
// Check if there needs to be a PHI in BB.
PHINode *NewPHI = 0;
if (Info->DefBB == BB) {
// Look for an existing PHI.
FindExistingPHI(BB);
if (!Info->AvailableVal) {
NewPHI = PHINode::Create(PrototypeValue->getType(),
PrototypeValue->getName(), &BB->front());
NewPHI->reserveOperandSpace(Info->NumPreds);
Info->AvailableVal = NewPHI;
AvailableVals[BB] = NewPHI;
} }
} }
// Iterate through the block's predecessors. // If there are no predecessors, then we must have found an unreachable block
Info->Counter = Counter; // just return 'undef'. Since there are no predecessors, InsertRes must not
for (unsigned pi = 0; pi != Info->NumPreds; ++pi) { // be invalidated.
BasicBlock *Pred = Info->Preds[pi]; if (IncomingPredInfo.size() == FirstPredInfoEntry)
BBInfo *PredInfo = (*BBMap)[Pred]; return InsertRes.first->second = UndefValue::get(PrototypeValue->getType());
FindAvailableVal(Pred, PredInfo, Counter);
if (NewPHI) { /// Look up BB's entry in AvailableVals. 'InsertRes' may be invalidated. If
// Skip to the nearest preceding definition. /// this block is involved in a loop, a no-entry PHI node will have been
if (PredInfo->DefBB != Pred) /// inserted as InsertedVal. Otherwise, we'll still have the null we inserted
PredInfo = (*BBMap)[PredInfo->DefBB]; /// above.
NewPHI->addIncoming(PredInfo->AvailableVal, Pred); TrackingVH<Value> &InsertedVal = AvailableVals[BB];
} else if (!Info->AvailableVal)
Info->AvailableVal = PredInfo->AvailableVal; // If the predecessor values are not all the same, then check to see if there
// is an existing PHI that can be used.
if (!ExistingValue)
ExistingValue = GetExistingPHI(BB,
IncomingPredInfo.begin()+FirstPredInfoEntry,
IncomingPredInfo.end());
// If there is an existing value we can use, then we don't need to insert a
// PHI. This is the simple and common case.
if (ExistingValue) {
// If a PHI node got inserted, replace it with the existing value and delete
// it.
if (InsertedVal) {
PHINode *OldVal = cast<PHINode>(InsertedVal);
// Be careful about dead loops. These RAUW's also update InsertedVal.
if (InsertedVal != ExistingValue)
OldVal->replaceAllUsesWith(ExistingValue);
else
OldVal->replaceAllUsesWith(UndefValue::get(InsertedVal->getType()));
OldVal->eraseFromParent();
} else {
InsertedVal = ExistingValue;
}
// Either path through the 'if' should have set InsertedVal -> ExistingVal.
assert((InsertedVal == ExistingValue || isa<UndefValue>(InsertedVal)) &&
"RAUW didn't change InsertedVal to be ExistingValue");
// Drop the entries we added in IncomingPredInfo to restore the stack.
IncomingPredInfo.erase(IncomingPredInfo.begin()+FirstPredInfoEntry,
IncomingPredInfo.end());
return ExistingValue;
} }
if (NewPHI) { // Otherwise, we do need a PHI: insert one now if we don't already have one.
DEBUG(dbgs() << " Inserted PHI: " << *NewPHI << "\n"); if (InsertedVal == 0)
InsertedVal = PHINode::Create(PrototypeValue->getType(),
PrototypeValue->getName(), &BB->front());
PHINode *InsertedPHI = cast<PHINode>(InsertedVal);
InsertedPHI->reserveOperandSpace(IncomingPredInfo.size()-FirstPredInfoEntry);
// Fill in all the predecessors of the PHI.
for (IncomingPredInfoTy::iterator I =
IncomingPredInfo.begin()+FirstPredInfoEntry,
E = IncomingPredInfo.end(); I != E; ++I)
InsertedPHI->addIncoming(I->second, I->first);
// Drop the entries we added in IncomingPredInfo to restore the stack.
IncomingPredInfo.erase(IncomingPredInfo.begin()+FirstPredInfoEntry,
IncomingPredInfo.end());
// See if the PHI node can be merged to a single value. This can happen in
// loop cases when we get a PHI of itself and one other value.
if (Value *ConstVal = InsertedPHI->hasConstantValue()) {
InsertedPHI->replaceAllUsesWith(ConstVal);
InsertedPHI->eraseFromParent();
InsertedVal = ConstVal;
} else {
DEBUG(dbgs() << " Inserted PHI: " << *InsertedPHI << "\n");
// If the client wants to know about all new instructions, tell it. // If the client wants to know about all new instructions, tell it.
if (InsertedPHIs) InsertedPHIs->push_back(NewPHI); if (InsertedPHIs) InsertedPHIs->push_back(InsertedPHI);
}
}
/// FindExistingPHI - Look through the PHI nodes in a block to see if any of
/// them match what is needed.
void SSAUpdater::FindExistingPHI(BasicBlock *BB) {
PHINode *SomePHI;
for (BasicBlock::iterator It = BB->begin();
(SomePHI = dyn_cast<PHINode>(It)); ++It) {
if (CheckIfPHIMatches(SomePHI)) {
RecordMatchingPHI(SomePHI);
break;
}
ClearPHITags(SomePHI);
}
}
/// CheckIfPHIMatches - Check if a PHI node matches the placement and values
/// in the BBMap.
bool SSAUpdater::CheckIfPHIMatches(PHINode *PHI) {
BBMapTy *BBMap = getBBMap(BM);
SmallVector<PHINode*, 20> WorkList;
WorkList.push_back(PHI);
// Mark that the block containing this PHI has been visited.
(*BBMap)[PHI->getParent()]->PHITag = PHI;
while (!WorkList.empty()) {
PHI = WorkList.pop_back_val();
// Iterate through the PHI's incoming values.
for (unsigned i = 0, e = PHI->getNumIncomingValues(); i != e; ++i) {
Value *IncomingVal = PHI->getIncomingValue(i);
BasicBlock *Pred = PHI->getIncomingBlock(i);
BBInfo *PredInfo = (*BBMap)[Pred];
// Skip to the nearest preceding definition.
if (PredInfo->DefBB != Pred) {
Pred = PredInfo->DefBB;
PredInfo = (*BBMap)[Pred];
}
// Check if it matches the expected value.
if (PredInfo->AvailableVal) {
if (IncomingVal == PredInfo->AvailableVal)
continue;
return false;
}
// Check if the value is a PHI in the correct block.
PHINode *IncomingPHIVal = dyn_cast<PHINode>(IncomingVal);
if (!IncomingPHIVal || IncomingPHIVal->getParent() != Pred)
return false;
// If this block has already been visited, check if this PHI matches.
if (PredInfo->PHITag) {
if (IncomingPHIVal == PredInfo->PHITag)
continue;
return false;
}
PredInfo->PHITag = IncomingPHIVal;
WorkList.push_back(IncomingPHIVal);
}
}
return true;
}
/// RecordMatchingPHI - For a PHI node that matches, record it and its input
/// PHIs in both the BBMap and the AvailableVals mapping.
void SSAUpdater::RecordMatchingPHI(PHINode *PHI) {
BBMapTy *BBMap = getBBMap(BM);
AvailableValsTy &AvailableVals = getAvailableVals(AV);
SmallVector<PHINode*, 20> WorkList;
WorkList.push_back(PHI);
// Record this PHI.
BasicBlock *BB = PHI->getParent();
AvailableVals[BB] = PHI;
(*BBMap)[BB]->AvailableVal = PHI;
while (!WorkList.empty()) {
PHI = WorkList.pop_back_val();
// Iterate through the PHI's incoming values.
for (unsigned i = 0, e = PHI->getNumIncomingValues(); i != e; ++i) {
PHINode *IncomingPHIVal = dyn_cast<PHINode>(PHI->getIncomingValue(i));
if (!IncomingPHIVal) continue;
BB = IncomingPHIVal->getParent();
BBInfo *Info = (*BBMap)[BB];
if (!Info || Info->AvailableVal)
continue;
// Record the PHI and add it to the worklist.
AvailableVals[BB] = IncomingPHIVal;
Info->AvailableVal = IncomingPHIVal;
WorkList.push_back(IncomingPHIVal);
}
}
}
/// ClearPHITags - When one of the existing PHI nodes fails to match, clear
/// the PHITag values that were stored in the BBMap when checking to see if
/// it matched.
void SSAUpdater::ClearPHITags(PHINode *PHI) {
BBMapTy *BBMap = getBBMap(BM);
SmallVector<PHINode*, 20> WorkList;
WorkList.push_back(PHI);
// Clear the tag for this PHI.
(*BBMap)[PHI->getParent()]->PHITag = 0;
while (!WorkList.empty()) {
PHI = WorkList.pop_back_val();
// Iterate through the PHI's incoming values.
for (unsigned i = 0, e = PHI->getNumIncomingValues(); i != e; ++i) {
PHINode *IncomingPHIVal = dyn_cast<PHINode>(PHI->getIncomingValue(i));
if (!IncomingPHIVal) continue;
BasicBlock *BB = IncomingPHIVal->getParent();
BBInfo *Info = (*BBMap)[BB];
if (!Info || Info->AvailableVal || !Info->PHITag)
continue;
// Clear the tag and add the PHI to the worklist.
Info->PHITag = 0;
WorkList.push_back(IncomingPHIVal);
}
} }
return InsertedVal;
} }

46
test/Transforms/GVN/2010-03-31-RedundantPHIs.ll
View File

@@ -1,46 +0,0 @@
; RUN: opt < %s -gvn -enable-full-load-pre -S | FileCheck %s
define i8* @cat(i8* %s1, ...) nounwind {
entry:
br i1 undef, label %bb, label %bb3
bb: ; preds = %entry
unreachable
bb3: ; preds = %entry
store i8* undef, i8** undef, align 4
br i1 undef, label %bb5, label %bb6
bb5: ; preds = %bb3
unreachable
bb6: ; preds = %bb3
br label %bb12
bb8: ; preds = %bb12
br i1 undef, label %bb9, label %bb10
bb9: ; preds = %bb8
%0 = load i8** undef, align 4 ; <i8*> [#uses=0]
%1 = load i8** undef, align 4 ; <i8*> [#uses=0]
br label %bb11
bb10: ; preds = %bb8
br label %bb11
bb11: ; preds = %bb10, %bb9
; CHECK: bb11:
; CHECK: phi
; CHECK-NOT: phi
br label %bb12
bb12: ; preds = %bb11, %bb6
; CHECK: bb12:
; CHECK: phi
; CHECK-NOT: phi
br i1 undef, label %bb8, label %bb13
bb13: ; preds = %bb12
; CHECK: bb13:
ret i8* undef
}