6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2024-07-21 02:29:22 +00:00
Code Issues Projects Releases Wiki Activity

hasConstantValue will soon return instructions that don't dominate the PHI node,

Browse Source 
so prepare for this.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@17095 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Chris Lattner 2004-10-17 21:22:38 +00:00
parent 665825e58e
commit c30bda7540
2 changed files with 39 additions and 20 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
lib/Transforms/Scalar/InstructionCombining.cpp
View File

@ -3364,7 +3364,7 @@ bool InstCombiner::transformConstExprCastCall(CallSite CS) {
}
AddUsersToWorkList(*Caller);
} else {
NV = Constant::getNullValue(Caller->getType());
NV = UndefValue::get(Caller->getType());
}
}
@ -3380,9 +3380,23 @@ bool InstCombiner::transformConstExprCastCall(CallSite CS) {
// PHINode simplification
//
Instruction *InstCombiner::visitPHINode(PHINode &PN) {
// FIXME: hasConstantValue should ignore undef values!
if (Value *V = hasConstantValue(&PN))
return ReplaceInstUsesWith(PN, V);
if (Value *V = hasConstantValue(&PN)) {
// If V is an instruction, we have to be certain that it dominates PN.
// However, because we don't have dom info, we can't do a perfect job.
if (Instruction *I = dyn_cast<Instruction>(V)) {
// We know that the instruction dominates the PHI if there are no undef
// values coming in.
for (unsigned i = 0, e = PN.getNumIncomingValues(); i != e; ++i)
if (isa<UndefValue>(PN.getIncomingValue(i))) {
std::cerr << "HAD TO DISABLE PHI ELIM IN IC!\n";
V = 0;
break;
}
}
if (V)
return ReplaceInstUsesWith(PN, V);
}
// If the only user of this instruction is a cast instruction, and all of the
// incoming values are constants, change this PHI to merge together the casted

37
lib/Transforms/Utils/LoopSimplify.cpp
View File

@ -250,8 +250,11 @@ BasicBlock *LoopSimplify::SplitBlockPredecessors(BasicBlock *BB,
// Can we eliminate this phi node now?
if (Value *V = hasConstantValue(PN)) {
PN->replaceAllUsesWith(V);
BB->getInstList().erase(PN);
if (!isa<Instruction>(V) ||
getAnalysis<DominatorSet>().dominates(cast<Instruction>(V), PN)) {
PN->replaceAllUsesWith(V);
BB->getInstList().erase(PN);
}
}
}
@ -426,22 +429,24 @@ static void AddBlockAndPredsToSet(BasicBlock *BB, BasicBlock *StopBlock,
/// FindPHIToPartitionLoops - The first part of loop-nestification is to find a
/// PHI node that tells us how to partition the loops.
static PHINode *FindPHIToPartitionLoops(Loop *L) {
static PHINode *FindPHIToPartitionLoops(Loop *L, DominatorSet &DS) {
for (BasicBlock::iterator I = L->getHeader()->begin(); isa<PHINode>(I); ) {
PHINode *PN = cast<PHINode>(I);
++I;
if (Value *V = hasConstantValue(PN)) {
// This is a degenerate PHI already, don't modify it!
PN->replaceAllUsesWith(V);
PN->getParent()->getInstList().erase(PN);
} else {
// Scan this PHI node looking for a use of the PHI node by itself.
for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i)
if (PN->getIncomingValue(i) == PN &&
L->contains(PN->getIncomingBlock(i)))
// We found something tasty to remove.
return PN;
}
if (Value *V = hasConstantValue(PN))
if (!isa<Instruction>(V) || DS.dominates(cast<Instruction>(V), PN)) {
// This is a degenerate PHI already, don't modify it!
PN->replaceAllUsesWith(V);
PN->getParent()->getInstList().erase(PN);
continue;
}
// Scan this PHI node looking for a use of the PHI node by itself.
for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i)
if (PN->getIncomingValue(i) == PN &&
L->contains(PN->getIncomingBlock(i)))
// We found something tasty to remove.
return PN;
}
return 0;
}
@ -464,7 +469,7 @@ static PHINode *FindPHIToPartitionLoops(Loop *L) {
/// created.
///
Loop *LoopSimplify::SeparateNestedLoop(Loop *L) {
PHINode *PN = FindPHIToPartitionLoops(L);
PHINode *PN = FindPHIToPartitionLoops(L, getAnalysis<DominatorSet>());
if (PN == 0) return 0; // No known way to partition.
// Pull out all predecessors that have varying values in the loop. This