1//===- DCE.cpp - Code to perform dead code elimination --------------------===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9// 10// This file implements dead inst elimination and dead code elimination. 11// 12// Dead Inst Elimination performs a single pass over the function removing 13// instructions that are obviously dead. Dead Code Elimination is similar, but 14// it rechecks instructions that were used by removed instructions to see if 15// they are newly dead. 16// 17//===----------------------------------------------------------------------===// 18 19#define DEBUG_TYPE "dce" 20#include "llvm/Transforms/Scalar.h" 21#include "llvm/Transforms/Utils/Local.h" 22#include "llvm/Instruction.h" 23#include "llvm/Pass.h"
| 1//===- DCE.cpp - Code to perform dead code elimination --------------------===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9// 10// This file implements dead inst elimination and dead code elimination. 11// 12// Dead Inst Elimination performs a single pass over the function removing 13// instructions that are obviously dead. Dead Code Elimination is similar, but 14// it rechecks instructions that were used by removed instructions to see if 15// they are newly dead. 16// 17//===----------------------------------------------------------------------===// 18 19#define DEBUG_TYPE "dce" 20#include "llvm/Transforms/Scalar.h" 21#include "llvm/Transforms/Utils/Local.h" 22#include "llvm/Instruction.h" 23#include "llvm/Pass.h"
|
24#include "llvm/Support/Compiler.h"
| |
25#include "llvm/Support/InstIterator.h" 26#include "llvm/ADT/Statistic.h" 27#include <set> 28using namespace llvm; 29 30STATISTIC(DIEEliminated, "Number of insts removed by DIE pass"); 31STATISTIC(DCEEliminated, "Number of insts removed"); 32 33namespace { 34 //===--------------------------------------------------------------------===// 35 // DeadInstElimination pass implementation 36 //
| 24#include "llvm/Support/InstIterator.h" 25#include "llvm/ADT/Statistic.h" 26#include <set> 27using namespace llvm; 28 29STATISTIC(DIEEliminated, "Number of insts removed by DIE pass"); 30STATISTIC(DCEEliminated, "Number of insts removed"); 31 32namespace { 33 //===--------------------------------------------------------------------===// 34 // DeadInstElimination pass implementation 35 //
|
37 struct VISIBILITY_HIDDEN DeadInstElimination : public BasicBlockPass {
| 36 struct DeadInstElimination : public BasicBlockPass {
|
38 static char ID; // Pass identification, replacement for typeid 39 DeadInstElimination() : BasicBlockPass(&ID) {} 40 virtual bool runOnBasicBlock(BasicBlock &BB) { 41 bool Changed = false; 42 for (BasicBlock::iterator DI = BB.begin(); DI != BB.end(); ) { 43 Instruction *Inst = DI++; 44 if (isInstructionTriviallyDead(Inst)) { 45 Inst->eraseFromParent(); 46 Changed = true; 47 ++DIEEliminated; 48 } 49 } 50 return Changed; 51 } 52 53 virtual void getAnalysisUsage(AnalysisUsage &AU) const { 54 AU.setPreservesCFG(); 55 } 56 }; 57} 58 59char DeadInstElimination::ID = 0; 60static RegisterPass<DeadInstElimination> 61X("die", "Dead Instruction Elimination"); 62 63Pass *llvm::createDeadInstEliminationPass() { 64 return new DeadInstElimination(); 65} 66 67 68namespace { 69 //===--------------------------------------------------------------------===// 70 // DeadCodeElimination pass implementation 71 // 72 struct DCE : public FunctionPass { 73 static char ID; // Pass identification, replacement for typeid 74 DCE() : FunctionPass(&ID) {} 75 76 virtual bool runOnFunction(Function &F); 77 78 virtual void getAnalysisUsage(AnalysisUsage &AU) const { 79 AU.setPreservesCFG(); 80 } 81 }; 82} 83 84char DCE::ID = 0; 85static RegisterPass<DCE> Y("dce", "Dead Code Elimination"); 86 87bool DCE::runOnFunction(Function &F) { 88 // Start out with all of the instructions in the worklist... 89 std::vector<Instruction*> WorkList; 90 for (inst_iterator i = inst_begin(F), e = inst_end(F); i != e; ++i) 91 WorkList.push_back(&*i); 92 93 // Loop over the worklist finding instructions that are dead. If they are 94 // dead make them drop all of their uses, making other instructions 95 // potentially dead, and work until the worklist is empty. 96 // 97 bool MadeChange = false; 98 while (!WorkList.empty()) { 99 Instruction *I = WorkList.back(); 100 WorkList.pop_back(); 101 102 if (isInstructionTriviallyDead(I)) { // If the instruction is dead. 103 // Loop over all of the values that the instruction uses, if there are 104 // instructions being used, add them to the worklist, because they might 105 // go dead after this one is removed. 106 // 107 for (User::op_iterator OI = I->op_begin(), E = I->op_end(); OI != E; ++OI) 108 if (Instruction *Used = dyn_cast<Instruction>(*OI)) 109 WorkList.push_back(Used); 110 111 // Remove the instruction. 112 I->eraseFromParent(); 113 114 // Remove the instruction from the worklist if it still exists in it. 115 for (std::vector<Instruction*>::iterator WI = WorkList.begin(); 116 WI != WorkList.end(); ) { 117 if (*WI == I) 118 WI = WorkList.erase(WI); 119 else 120 ++WI; 121 } 122 123 MadeChange = true; 124 ++DCEEliminated; 125 } 126 } 127 return MadeChange; 128} 129 130FunctionPass *llvm::createDeadCodeEliminationPass() { 131 return new DCE(); 132} 133
| 37 static char ID; // Pass identification, replacement for typeid 38 DeadInstElimination() : BasicBlockPass(&ID) {} 39 virtual bool runOnBasicBlock(BasicBlock &BB) { 40 bool Changed = false; 41 for (BasicBlock::iterator DI = BB.begin(); DI != BB.end(); ) { 42 Instruction *Inst = DI++; 43 if (isInstructionTriviallyDead(Inst)) { 44 Inst->eraseFromParent(); 45 Changed = true; 46 ++DIEEliminated; 47 } 48 } 49 return Changed; 50 } 51 52 virtual void getAnalysisUsage(AnalysisUsage &AU) const { 53 AU.setPreservesCFG(); 54 } 55 }; 56} 57 58char DeadInstElimination::ID = 0; 59static RegisterPass<DeadInstElimination> 60X("die", "Dead Instruction Elimination"); 61 62Pass *llvm::createDeadInstEliminationPass() { 63 return new DeadInstElimination(); 64} 65 66 67namespace { 68 //===--------------------------------------------------------------------===// 69 // DeadCodeElimination pass implementation 70 // 71 struct DCE : public FunctionPass { 72 static char ID; // Pass identification, replacement for typeid 73 DCE() : FunctionPass(&ID) {} 74 75 virtual bool runOnFunction(Function &F); 76 77 virtual void getAnalysisUsage(AnalysisUsage &AU) const { 78 AU.setPreservesCFG(); 79 } 80 }; 81} 82 83char DCE::ID = 0; 84static RegisterPass<DCE> Y("dce", "Dead Code Elimination"); 85 86bool DCE::runOnFunction(Function &F) { 87 // Start out with all of the instructions in the worklist... 88 std::vector<Instruction*> WorkList; 89 for (inst_iterator i = inst_begin(F), e = inst_end(F); i != e; ++i) 90 WorkList.push_back(&*i); 91 92 // Loop over the worklist finding instructions that are dead. If they are 93 // dead make them drop all of their uses, making other instructions 94 // potentially dead, and work until the worklist is empty. 95 // 96 bool MadeChange = false; 97 while (!WorkList.empty()) { 98 Instruction *I = WorkList.back(); 99 WorkList.pop_back(); 100 101 if (isInstructionTriviallyDead(I)) { // If the instruction is dead. 102 // Loop over all of the values that the instruction uses, if there are 103 // instructions being used, add them to the worklist, because they might 104 // go dead after this one is removed. 105 // 106 for (User::op_iterator OI = I->op_begin(), E = I->op_end(); OI != E; ++OI) 107 if (Instruction *Used = dyn_cast<Instruction>(*OI)) 108 WorkList.push_back(Used); 109 110 // Remove the instruction. 111 I->eraseFromParent(); 112 113 // Remove the instruction from the worklist if it still exists in it. 114 for (std::vector<Instruction*>::iterator WI = WorkList.begin(); 115 WI != WorkList.end(); ) { 116 if (*WI == I) 117 WI = WorkList.erase(WI); 118 else 119 ++WI; 120 } 121 122 MadeChange = true; 123 ++DCEEliminated; 124 } 125 } 126 return MadeChange; 127} 128 129FunctionPass *llvm::createDeadCodeEliminationPass() { 130 return new DCE(); 131} 132
|