Mercurial > hg > CbC > CbC_llvm

comparison lib/CodeGen/UnreachableBlockElim.cpp @ 120:1172e4bd9c6f

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
update 4.0.0
author mir3636
date Fri, 25 Nov 2016 19:14:25 +0900
parents afa8332a0e37
children 803732b1fca8
comparison
equal deleted inserted replaced
101:34baf5011add 120:1172e4bd9c6f
18 // selectors, however, we cannot really expect them to handle additional 18 // selectors, however, we cannot really expect them to handle additional
19 // complexity. 19 // complexity.
20 // 20 //
21 //===----------------------------------------------------------------------===// 21 //===----------------------------------------------------------------------===//
22 22
23 #include "llvm/CodeGen/Passes.h" 23 #include "llvm/CodeGen/UnreachableBlockElim.h"
24 #include "llvm/ADT/DepthFirstIterator.h" 24 #include "llvm/ADT/DepthFirstIterator.h"
25 #include "llvm/ADT/SmallPtrSet.h" 25 #include "llvm/ADT/SmallPtrSet.h"
26 #include "llvm/CodeGen/MachineDominators.h" 26 #include "llvm/CodeGen/MachineDominators.h"
27 #include "llvm/CodeGen/MachineFunctionPass.h" 27 #include "llvm/CodeGen/MachineFunctionPass.h"
28 #include "llvm/CodeGen/MachineLoopInfo.h" 28 #include "llvm/CodeGen/MachineLoopInfo.h"
29 #include "llvm/CodeGen/MachineModuleInfo.h" 29 #include "llvm/CodeGen/MachineModuleInfo.h"
30 #include "llvm/CodeGen/MachineRegisterInfo.h" 30 #include "llvm/CodeGen/MachineRegisterInfo.h"
31 #include "llvm/CodeGen/Passes.h"
31 #include "llvm/IR/CFG.h" 32 #include "llvm/IR/CFG.h"
32 #include "llvm/IR/Constant.h" 33 #include "llvm/IR/Constant.h"
33 #include "llvm/IR/Dominators.h" 34 #include "llvm/IR/Dominators.h"
34 #include "llvm/IR/Function.h" 35 #include "llvm/IR/Function.h"
35 #include "llvm/IR/Instructions.h" 36 #include "llvm/IR/Instructions.h"
36 #include "llvm/IR/Type.h" 37 #include "llvm/IR/Type.h"
37 #include "llvm/Pass.h" 38 #include "llvm/Pass.h"
38 #include "llvm/Target/TargetInstrInfo.h" 39 #include "llvm/Target/TargetInstrInfo.h"
39 using namespace llvm; 40 using namespace llvm;
40 41
41 namespace { 42 static bool eliminateUnreachableBlock(Function &F) {
42 class UnreachableBlockElim : public FunctionPass { 43 df_iterator_default_set<BasicBlock*> Reachable;
43 bool runOnFunction(Function &F) override;
44 public:
45 static char ID; // Pass identification, replacement for typeid
46 UnreachableBlockElim() : FunctionPass(ID) {
47 initializeUnreachableBlockElimPass(*PassRegistry::getPassRegistry());
48 }
49
50 void getAnalysisUsage(AnalysisUsage &AU) const override {
51 AU.addPreserved<DominatorTreeWrapperPass>();
52 }
53 };
54 }
55 char UnreachableBlockElim::ID = 0;
56 INITIALIZE_PASS(UnreachableBlockElim, "unreachableblockelim",
57 "Remove unreachable blocks from the CFG", false, false)
58
59 FunctionPass *llvm::createUnreachableBlockEliminationPass() {
60 return new UnreachableBlockElim();
61 }
62
63 bool UnreachableBlockElim::runOnFunction(Function &F) {
64 SmallPtrSet<BasicBlock*, 8> Reachable;
65 44
66 // Mark all reachable blocks. 45 // Mark all reachable blocks.
67 for (BasicBlock *BB : depth_first_ext(&F, Reachable)) 46 for (BasicBlock *BB : depth_first_ext(&F, Reachable))
68 (void)BB/* Mark all reachable blocks */; 47 (void)BB/* Mark all reachable blocks */;
69 48
89 } 68 }
90 69
91 return !DeadBlocks.empty(); 70 return !DeadBlocks.empty();
92 } 71 }
93 72
73 namespace {
74 class UnreachableBlockElimLegacyPass : public FunctionPass {
75 bool runOnFunction(Function &F) override {
76 return eliminateUnreachableBlock(F);
77 }
78
79 public:
80 static char ID; // Pass identification, replacement for typeid
81 UnreachableBlockElimLegacyPass() : FunctionPass(ID) {
82 initializeUnreachableBlockElimLegacyPassPass(
83 *PassRegistry::getPassRegistry());
84 }
85
86 void getAnalysisUsage(AnalysisUsage &AU) const override {
87 AU.addPreserved<DominatorTreeWrapperPass>();
88 }
89 };
90 }
91 char UnreachableBlockElimLegacyPass::ID = 0;
92 INITIALIZE_PASS(UnreachableBlockElimLegacyPass, "unreachableblockelim",
93 "Remove unreachable blocks from the CFG", false, false)
94
95 FunctionPass *llvm::createUnreachableBlockEliminationPass() {
96 return new UnreachableBlockElimLegacyPass();
97 }
98
99 PreservedAnalyses UnreachableBlockElimPass::run(Function &F,
100 FunctionAnalysisManager &AM) {
101 bool Changed = eliminateUnreachableBlock(F);
102 if (!Changed)
103 return PreservedAnalyses::all();
104 PreservedAnalyses PA;
105 PA.preserve<DominatorTreeAnalysis>();
106 return PA;
107 }
94 108
95 namespace { 109 namespace {
96 class UnreachableMachineBlockElim : public MachineFunctionPass { 110 class UnreachableMachineBlockElim : public MachineFunctionPass {
97 bool runOnMachineFunction(MachineFunction &F) override; 111 bool runOnMachineFunction(MachineFunction &F) override;
98 void getAnalysisUsage(AnalysisUsage &AU) const override; 112 void getAnalysisUsage(AnalysisUsage &AU) const override;
114 AU.addPreserved<MachineDominatorTree>(); 128 AU.addPreserved<MachineDominatorTree>();
115 MachineFunctionPass::getAnalysisUsage(AU); 129 MachineFunctionPass::getAnalysisUsage(AU);
116 } 130 }
117 131
118 bool UnreachableMachineBlockElim::runOnMachineFunction(MachineFunction &F) { 132 bool UnreachableMachineBlockElim::runOnMachineFunction(MachineFunction &F) {
119 SmallPtrSet<MachineBasicBlock*, 8> Reachable; 133 df_iterator_default_set<MachineBasicBlock*> Reachable;
120 bool ModifiedPHI = false; 134 bool ModifiedPHI = false;
121 135
122 MMI = getAnalysisIfAvailable<MachineModuleInfo>(); 136 MMI = getAnalysisIfAvailable<MachineModuleInfo>();
123 MachineDominatorTree *MDT = getAnalysisIfAvailable<MachineDominatorTree>(); 137 MachineDominatorTree *MDT = getAnalysisIfAvailable<MachineDominatorTree>();
124 MachineLoopInfo *MLI = getAnalysisIfAvailable<MachineLoopInfo>(); 138 MachineLoopInfo *MLI = getAnalysisIfAvailable<MachineLoopInfo>();
182 196
183 if (phi->getNumOperands() == 3) { 197 if (phi->getNumOperands() == 3) {
184 unsigned Input = phi->getOperand(1).getReg(); 198 unsigned Input = phi->getOperand(1).getReg();
185 unsigned Output = phi->getOperand(0).getReg(); 199 unsigned Output = phi->getOperand(0).getReg();
186 200
187 MachineInstr* temp = phi; 201 phi++->eraseFromParent();
188 ++phi;
189 temp->eraseFromParent();
190 ModifiedPHI = true; 202 ModifiedPHI = true;
191 203
192 if (Input != Output) { 204 if (Input != Output) {
193 MachineRegisterInfo &MRI = F.getRegInfo(); 205 MachineRegisterInfo &MRI = F.getRegInfo();
194 MRI.constrainRegClass(Input, MRI.getRegClass(Output)); 206 MRI.constrainRegClass(Input, MRI.getRegClass(Output));