mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-08-17 05:29:24 +00:00
Fix a fixme in CondPropagate.cpp by moving a PhiNode optimization into
BasicBlock's removePredecessor routine. This requires shuffling around the definition and implementation of hasContantValue from Utils.h,cpp into Instructions.h,cpp git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@22664 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
parent
f065f05397
commit
a83ba0f5c9
@ -804,6 +804,11 @@ public:
|
||||
return getIncomingValue(getBasicBlockIndex(BB));
|
||||
}
|
||||
|
||||
/// hasConstantValue - If the specified PHI node always merges together the
|
||||
/// same value, return the value, otherwise return null.
|
||||
///
|
||||
Value *hasConstantValue();
|
||||
|
||||
/// Methods for support type inquiry through isa, cast, and dyn_cast:
|
||||
static inline bool classof(const PHINode *) { return true; }
|
||||
static inline bool classof(const Instruction *I) {
|
||||
|
@ -73,16 +73,6 @@ bool isInstructionTriviallyDead(Instruction *I);
|
||||
///
|
||||
bool dceInstruction(BasicBlock::iterator &BBI);
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// PHI Instruction Simplification
|
||||
//
|
||||
|
||||
/// hasConstantValue - If the specified PHI node always merges together the same
|
||||
/// value, return the value, otherwise return null.
|
||||
///
|
||||
Value *hasConstantValue(PHINode *PN);
|
||||
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// Control Flow Graph Restructuring...
|
||||
//
|
||||
|
@ -80,17 +80,6 @@ void CondProp::SimplifyBlock(BasicBlock *BB) {
|
||||
SimplifyPredecessors(SI);
|
||||
}
|
||||
|
||||
// See if we can fold any PHI nodes in this block now.
|
||||
// FIXME: This would not be required if removePredecessor did this for us!!
|
||||
PHINode *PN;
|
||||
for (BasicBlock::iterator I = BB->begin(); (PN = dyn_cast<PHINode>(I++)); )
|
||||
if (Value *PNV = hasConstantValue(PN))
|
||||
if (!isa<Instruction>(PNV)) {
|
||||
PN->replaceAllUsesWith(PNV);
|
||||
PN->eraseFromParent();
|
||||
MadeChange = true;
|
||||
}
|
||||
|
||||
// If possible, simplify the terminator of this block.
|
||||
if (ConstantFoldTerminator(BB))
|
||||
MadeChange = true;
|
||||
|
@ -4401,7 +4401,7 @@ static bool DeadPHICycle(PHINode *PN, std::set<PHINode*> &PotentiallyDeadPHIs) {
|
||||
// PHINode simplification
|
||||
//
|
||||
Instruction *InstCombiner::visitPHINode(PHINode &PN) {
|
||||
if (Value *V = hasConstantValue(&PN)) {
|
||||
if (Value *V = PN.hasConstantValue()) {
|
||||
// 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)) {
|
||||
|
@ -406,37 +406,3 @@ bool llvm::dceInstruction(BasicBlock::iterator &BBI) {
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// PHI Instruction Simplification
|
||||
//
|
||||
|
||||
/// hasConstantValue - If the specified PHI node always merges together the same
|
||||
/// value, return the value, otherwise return null.
|
||||
///
|
||||
Value *llvm::hasConstantValue(PHINode *PN) {
|
||||
// If the PHI node only has one incoming value, eliminate the PHI node...
|
||||
if (PN->getNumIncomingValues() == 1)
|
||||
return PN->getIncomingValue(0);
|
||||
|
||||
// Otherwise if all of the incoming values are the same for the PHI, replace
|
||||
// the PHI node with the incoming value.
|
||||
//
|
||||
Value *InVal = 0;
|
||||
for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i)
|
||||
if (PN->getIncomingValue(i) != PN && // Not the PHI node itself...
|
||||
!isa<UndefValue>(PN->getIncomingValue(i)))
|
||||
if (InVal && PN->getIncomingValue(i) != InVal)
|
||||
return 0; // Not the same, bail out.
|
||||
else
|
||||
InVal = PN->getIncomingValue(i);
|
||||
|
||||
// The only case that could cause InVal to be null is if we have a PHI node
|
||||
// that only has entries for itself. In this case, there is no entry into the
|
||||
// loop, so kill the PHI.
|
||||
//
|
||||
if (InVal == 0) InVal = UndefValue::get(PN->getType());
|
||||
|
||||
// All of the incoming values are the same, return the value now.
|
||||
return InVal;
|
||||
}
|
||||
|
@ -41,7 +41,6 @@
|
||||
#include "llvm/Analysis/Dominators.h"
|
||||
#include "llvm/Analysis/LoopInfo.h"
|
||||
#include "llvm/Support/CFG.h"
|
||||
#include "llvm/Transforms/Utils/Local.h"
|
||||
#include "llvm/ADT/SetOperations.h"
|
||||
#include "llvm/ADT/SetVector.h"
|
||||
#include "llvm/ADT/Statistic.h"
|
||||
@ -257,7 +256,7 @@ BasicBlock *LoopSimplify::SplitBlockPredecessors(BasicBlock *BB,
|
||||
PN->addIncoming(InVal, NewBB);
|
||||
|
||||
// Can we eliminate this phi node now?
|
||||
if (Value *V = hasConstantValue(PN)) {
|
||||
if (Value *V = PN->hasConstantValue()) {
|
||||
if (!isa<Instruction>(V) ||
|
||||
getAnalysis<DominatorSet>().dominates(cast<Instruction>(V), PN)) {
|
||||
PN->replaceAllUsesWith(V);
|
||||
@ -443,7 +442,7 @@ 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))
|
||||
if (Value *V = PN->hasConstantValue())
|
||||
if (!isa<Instruction>(V) || DS.dominates(cast<Instruction>(V), PN)) {
|
||||
// This is a degenerate PHI already, don't modify it!
|
||||
PN->replaceAllUsesWith(V);
|
||||
|
@ -24,7 +24,6 @@
|
||||
#include "llvm/Analysis/Dominators.h"
|
||||
#include "llvm/Analysis/AliasSetTracker.h"
|
||||
#include "llvm/ADT/StringExtras.h"
|
||||
#include "llvm/Transforms/Utils/Local.h"
|
||||
#include "llvm/Support/CFG.h"
|
||||
#include "llvm/Support/StableBasicBlockNumbering.h"
|
||||
#include <algorithm>
|
||||
@ -348,7 +347,7 @@ void PromoteMem2Reg::run() {
|
||||
PHINode *SomePHI = 0;
|
||||
for (unsigned i = 0, e = PNs.size(); i != e; ++i)
|
||||
if (PNs[i]) {
|
||||
if (Value *V = hasConstantValue(PNs[i])) {
|
||||
if (Value *V = PNs[i]->hasConstantValue()) {
|
||||
if (!isa<Instruction>(V) || dominates(cast<Instruction>(V), PNs[i])) {
|
||||
if (AST && isa<PointerType>(PNs[i]->getType()))
|
||||
AST->deleteValue(PNs[i]);
|
||||
|
@ -189,8 +189,16 @@ void BasicBlock::removePredecessor(BasicBlock *Pred,
|
||||
// Okay, now we know that we need to remove predecessor #pred_idx from all
|
||||
// PHI nodes. Iterate over each PHI node fixing them up
|
||||
PHINode *PN;
|
||||
for (iterator II = begin(); (PN = dyn_cast<PHINode>(II)); ++II)
|
||||
for (iterator II = begin(); (PN = dyn_cast<PHINode>(II)); ++II) {
|
||||
PN->removeIncomingValue(Pred, false);
|
||||
// If all incoming values to the Phi are the same, we can replace the Phi
|
||||
// with that value.
|
||||
if (Value *PNV = PN->hasConstantValue())
|
||||
if (!isa<Instruction>(PNV)) {
|
||||
PN->replaceAllUsesWith(PNV);
|
||||
PN->eraseFromParent();
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -132,6 +132,36 @@ void PHINode::resizeOperands(unsigned NumOps) {
|
||||
OperandList = NewOps;
|
||||
}
|
||||
|
||||
/// hasConstantValue - If the specified PHI node always merges together the same
|
||||
/// value, return the value, otherwise return null.
|
||||
///
|
||||
Value *PHINode::hasConstantValue() {
|
||||
// If the PHI node only has one incoming value, eliminate the PHI node...
|
||||
if (getNumIncomingValues() == 1)
|
||||
return getIncomingValue(0);
|
||||
|
||||
// Otherwise if all of the incoming values are the same for the PHI, replace
|
||||
// the PHI node with the incoming value.
|
||||
//
|
||||
Value *InVal = 0;
|
||||
for (unsigned i = 0, e = getNumIncomingValues(); i != e; ++i)
|
||||
if (getIncomingValue(i) != this && // Not the PHI node itself...
|
||||
!isa<UndefValue>(getIncomingValue(i)))
|
||||
if (InVal && getIncomingValue(i) != InVal)
|
||||
return 0; // Not the same, bail out.
|
||||
else
|
||||
InVal = getIncomingValue(i);
|
||||
|
||||
// The only case that could cause InVal to be null is if we have a PHI node
|
||||
// that only has entries for itself. In this case, there is no entry into the
|
||||
// loop, so kill the PHI.
|
||||
//
|
||||
if (InVal == 0) InVal = UndefValue::get(getType());
|
||||
|
||||
// All of the incoming values are the same, return the value now.
|
||||
return InVal;
|
||||
}
|
||||
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// CallInst Implementation
|
||||
|
Loading…
Reference in New Issue
Block a user