Make RecursivelyDeleteTriviallyDeadInstructions,

RecursivelyDeleteDeadPHINode, and DeleteDeadPHIs return a flag
indicating whether they made any changes.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@92732 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Dan Gohman 2010-01-05 15:45:31 +00:00
parent ad2cee44e0
commit 90fe0bd68c
4 changed files with 25 additions and 15 deletions

View File

@ -40,8 +40,9 @@ void FoldSingleEntryPHINodes(BasicBlock *BB);
/// DeleteDeadPHIs - Examine each PHI in the given block and delete it if it /// DeleteDeadPHIs - Examine each PHI in the given block and delete it if it
/// is dead. Also recursively delete any operands that become dead as /// is dead. Also recursively delete any operands that become dead as
/// a result. This includes tracing the def-use list from the PHI to see if /// a result. This includes tracing the def-use list from the PHI to see if
/// it is ultimately unused or if it reaches an unused cycle. /// it is ultimately unused or if it reaches an unused cycle. Return true
void DeleteDeadPHIs(BasicBlock *BB); /// if any PHIs were deleted.
bool DeleteDeadPHIs(BasicBlock *BB);
/// MergeBlockIntoPredecessor - Attempts to merge a block into its predecessor, /// MergeBlockIntoPredecessor - Attempts to merge a block into its predecessor,
/// if possible. The return value indicates success or failure. /// if possible. The return value indicates success or failure.

View File

@ -63,15 +63,16 @@ bool isInstructionTriviallyDead(Instruction *I);
/// RecursivelyDeleteTriviallyDeadInstructions - If the specified value is a /// RecursivelyDeleteTriviallyDeadInstructions - If the specified value is a
/// trivially dead instruction, delete it. If that makes any of its operands /// trivially dead instruction, delete it. If that makes any of its operands
/// trivially dead, delete them too, recursively. /// trivially dead, delete them too, recursively. Return true if any
void RecursivelyDeleteTriviallyDeadInstructions(Value *V); /// instructions were deleted.
bool RecursivelyDeleteTriviallyDeadInstructions(Value *V);
/// RecursivelyDeleteDeadPHINode - If the specified value is an effectively /// RecursivelyDeleteDeadPHINode - If the specified value is an effectively
/// dead PHI node, due to being a def-use chain of single-use nodes that /// dead PHI node, due to being a def-use chain of single-use nodes that
/// either forms a cycle or is terminated by a trivially dead instruction, /// either forms a cycle or is terminated by a trivially dead instruction,
/// delete it. If that makes any of its operands trivially dead, delete them /// delete it. If that makes any of its operands trivially dead, delete them
/// too, recursively. /// too, recursively. Return true if the PHI node is actually deleted.
void RecursivelyDeleteDeadPHINode(PHINode *PN); bool RecursivelyDeleteDeadPHINode(PHINode *PN);
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Control Flow Graph Restructuring. // Control Flow Graph Restructuring.

View File

@ -78,7 +78,7 @@ void llvm::FoldSingleEntryPHINodes(BasicBlock *BB) {
/// is dead. Also recursively delete any operands that become dead as /// is dead. Also recursively delete any operands that become dead as
/// a result. This includes tracing the def-use list from the PHI to see if /// a result. This includes tracing the def-use list from the PHI to see if
/// it is ultimately unused or if it reaches an unused cycle. /// it is ultimately unused or if it reaches an unused cycle.
void llvm::DeleteDeadPHIs(BasicBlock *BB) { bool llvm::DeleteDeadPHIs(BasicBlock *BB) {
// Recursively deleting a PHI may cause multiple PHIs to be deleted // Recursively deleting a PHI may cause multiple PHIs to be deleted
// or RAUW'd undef, so use an array of WeakVH for the PHIs to delete. // or RAUW'd undef, so use an array of WeakVH for the PHIs to delete.
SmallVector<WeakVH, 8> PHIs; SmallVector<WeakVH, 8> PHIs;
@ -86,9 +86,12 @@ void llvm::DeleteDeadPHIs(BasicBlock *BB) {
PHINode *PN = dyn_cast<PHINode>(I); ++I) PHINode *PN = dyn_cast<PHINode>(I); ++I)
PHIs.push_back(PN); PHIs.push_back(PN);
bool Changed = false;
for (unsigned i = 0, e = PHIs.size(); i != e; ++i) for (unsigned i = 0, e = PHIs.size(); i != e; ++i)
if (PHINode *PN = dyn_cast_or_null<PHINode>(PHIs[i].operator Value*())) if (PHINode *PN = dyn_cast_or_null<PHINode>(PHIs[i].operator Value*()))
RecursivelyDeleteDeadPHINode(PN); Changed |= RecursivelyDeleteDeadPHINode(PN);
return Changed;
} }
/// MergeBlockIntoPredecessor - Attempts to merge a block into its predecessor, /// MergeBlockIntoPredecessor - Attempts to merge a block into its predecessor,

View File

@ -268,11 +268,12 @@ bool llvm::isInstructionTriviallyDead(Instruction *I) {
/// RecursivelyDeleteTriviallyDeadInstructions - If the specified value is a /// RecursivelyDeleteTriviallyDeadInstructions - If the specified value is a
/// trivially dead instruction, delete it. If that makes any of its operands /// trivially dead instruction, delete it. If that makes any of its operands
/// trivially dead, delete them too, recursively. /// trivially dead, delete them too, recursively. Return true if any
void llvm::RecursivelyDeleteTriviallyDeadInstructions(Value *V) { /// instructions were deleted.
bool llvm::RecursivelyDeleteTriviallyDeadInstructions(Value *V) {
Instruction *I = dyn_cast<Instruction>(V); Instruction *I = dyn_cast<Instruction>(V);
if (!I || !I->use_empty() || !isInstructionTriviallyDead(I)) if (!I || !I->use_empty() || !isInstructionTriviallyDead(I))
return; return false;
SmallVector<Instruction*, 16> DeadInsts; SmallVector<Instruction*, 16> DeadInsts;
DeadInsts.push_back(I); DeadInsts.push_back(I);
@ -298,21 +299,24 @@ void llvm::RecursivelyDeleteTriviallyDeadInstructions(Value *V) {
I->eraseFromParent(); I->eraseFromParent();
} }
return true;
} }
/// RecursivelyDeleteDeadPHINode - If the specified value is an effectively /// RecursivelyDeleteDeadPHINode - If the specified value is an effectively
/// dead PHI node, due to being a def-use chain of single-use nodes that /// dead PHI node, due to being a def-use chain of single-use nodes that
/// either forms a cycle or is terminated by a trivially dead instruction, /// either forms a cycle or is terminated by a trivially dead instruction,
/// delete it. If that makes any of its operands trivially dead, delete them /// delete it. If that makes any of its operands trivially dead, delete them
/// too, recursively. /// too, recursively. Return true if the PHI node is actually deleted.
void bool
llvm::RecursivelyDeleteDeadPHINode(PHINode *PN) { llvm::RecursivelyDeleteDeadPHINode(PHINode *PN) {
// We can remove a PHI if it is on a cycle in the def-use graph // We can remove a PHI if it is on a cycle in the def-use graph
// where each node in the cycle has degree one, i.e. only one use, // where each node in the cycle has degree one, i.e. only one use,
// and is an instruction with no side effects. // and is an instruction with no side effects.
if (!PN->hasOneUse()) if (!PN->hasOneUse())
return; return false;
bool Changed = false;
SmallPtrSet<PHINode *, 4> PHIs; SmallPtrSet<PHINode *, 4> PHIs;
PHIs.insert(PN); PHIs.insert(PN);
for (Instruction *J = cast<Instruction>(*PN->use_begin()); for (Instruction *J = cast<Instruction>(*PN->use_begin());
@ -324,9 +328,10 @@ llvm::RecursivelyDeleteDeadPHINode(PHINode *PN) {
if (!PHIs.insert(cast<PHINode>(JP))) { if (!PHIs.insert(cast<PHINode>(JP))) {
// Break the cycle and delete the PHI and its operands. // Break the cycle and delete the PHI and its operands.
JP->replaceAllUsesWith(UndefValue::get(JP->getType())); JP->replaceAllUsesWith(UndefValue::get(JP->getType()));
RecursivelyDeleteTriviallyDeadInstructions(JP); Changed |= RecursivelyDeleteTriviallyDeadInstructions(JP);
break; break;
} }
return Changed;
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//