}
AddUsersToWorkList(*Caller);
} else {
- NV = Constant::getNullValue(Caller->getType());
+ NV = UndefValue::get(Caller->getType());
}
}
// 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
// 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);
+ }
}
}
/// 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;
}
/// 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