LLVM  4.0.0
ADCE.cpp
Go to the documentation of this file.
1 //===- ADCE.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 the Aggressive Dead Code Elimination pass. This pass
11 // optimistically assumes that all instructions are dead until proven otherwise,
12 // allowing it to eliminate dead computations that other DCE passes do not
13 // catch, particularly involving loop computations.
14 //
15 //===----------------------------------------------------------------------===//
16 
18 
21 #include "llvm/ADT/SmallPtrSet.h"
22 #include "llvm/ADT/SmallVector.h"
23 #include "llvm/ADT/Statistic.h"
27 #include "llvm/IR/BasicBlock.h"
28 #include "llvm/IR/CFG.h"
30 #include "llvm/IR/IRBuilder.h"
31 #include "llvm/IR/InstIterator.h"
32 #include "llvm/IR/Instructions.h"
33 #include "llvm/IR/IntrinsicInst.h"
34 #include "llvm/Pass.h"
36 #include "llvm/Transforms/Scalar.h"
37 using namespace llvm;
38 
39 #define DEBUG_TYPE "adce"
40 
41 STATISTIC(NumRemoved, "Number of instructions removed");
42 STATISTIC(NumBranchesRemoved, "Number of branch instructions removed");
43 
44 // This is a tempoary option until we change the interface
45 // to this pass based on optimization level.
46 static cl::opt<bool> RemoveControlFlowFlag("adce-remove-control-flow",
47  cl::init(true), cl::Hidden);
48 
49 // This option enables removing of may-be-infinite loops which have no other
50 // effect.
51 static cl::opt<bool> RemoveLoops("adce-remove-loops", cl::init(false),
52  cl::Hidden);
53 
54 namespace {
55 /// Information about Instructions
56 struct InstInfoType {
57  /// True if the associated instruction is live.
58  bool Live = false;
59  /// Quick access to information for block containing associated Instruction.
60  struct BlockInfoType *Block = nullptr;
61 };
62 
63 /// Information about basic blocks relevant to dead code elimination.
64 struct BlockInfoType {
65  /// True when this block contains a live instructions.
66  bool Live = false;
67  /// True when this block ends in an unconditional branch.
68  bool UnconditionalBranch = false;
69  /// True when this block is known to have live PHI nodes.
70  bool HasLivePhiNodes = false;
71  /// Control dependence sources need to be live for this block.
72  bool CFLive = false;
73 
74  /// Quick access to the LiveInfo for the terminator,
75  /// holds the value &InstInfo[Terminator]
76  InstInfoType *TerminatorLiveInfo = nullptr;
77 
78  bool terminatorIsLive() const { return TerminatorLiveInfo->Live; }
79 
80  /// Corresponding BasicBlock.
81  BasicBlock *BB = nullptr;
82 
83  /// Cache of BB->getTerminator().
84  TerminatorInst *Terminator = nullptr;
85 
86  /// Post-order numbering of reverse control flow graph.
87  unsigned PostOrder;
88 };
89 
90 class AggressiveDeadCodeElimination {
91  Function &F;
92  PostDominatorTree &PDT;
93 
94  /// Mapping of blocks to associated information, an element in BlockInfoVec.
96  bool isLive(BasicBlock *BB) { return BlockInfo[BB].Live; }
97 
98  /// Mapping of instructions to associated information.
100  bool isLive(Instruction *I) { return InstInfo[I].Live; }
101 
102  /// Instructions known to be live where we need to mark
103  /// reaching definitions as live.
105  /// Debug info scopes around a live instruction.
107 
108  /// Set of blocks with not known to have live terminators.
109  SmallPtrSet<BasicBlock *, 16> BlocksWithDeadTerminators;
110 
111  /// The set of blocks which we have determined whose control
112  /// dependence sources must be live and which have not had
113  /// those dependences analyized.
114  SmallPtrSet<BasicBlock *, 16> NewLiveBlocks;
115 
116  /// Set up auxiliary data structures for Instructions and BasicBlocks and
117  /// initialize the Worklist to the set of must-be-live Instruscions.
118  void initialize();
119  /// Return true for operations which are always treated as live.
120  bool isAlwaysLive(Instruction &I);
121  /// Return true for instrumentation instructions for value profiling.
122  bool isInstrumentsConstant(Instruction &I);
123 
124  /// Propagate liveness to reaching definitions.
125  void markLiveInstructions();
126  /// Mark an instruction as live.
127  void markLive(Instruction *I);
128  /// Mark a block as live.
129  void markLive(BlockInfoType &BB);
130  void markLive(BasicBlock *BB) { markLive(BlockInfo[BB]); }
131 
132  /// Mark terminators of control predecessors of a PHI node live.
133  void markPhiLive(PHINode *PN);
134 
135  /// Record the Debug Scopes which surround live debug information.
136  void collectLiveScopes(const DILocalScope &LS);
137  void collectLiveScopes(const DILocation &DL);
138 
139  /// Analyze dead branches to find those whose branches are the sources
140  /// of control dependences impacting a live block. Those branches are
141  /// marked live.
142  void markLiveBranchesFromControlDependences();
143 
144  /// Remove instructions not marked live, return if any any instruction
145  /// was removed.
146  bool removeDeadInstructions();
147 
148  /// Identify connected sections of the control flow grap which have
149  /// dead terminators and rewrite the control flow graph to remove them.
150  void updateDeadRegions();
151 
152  /// Set the BlockInfo::PostOrder field based on a post-order
153  /// numbering of the reverse control flow graph.
154  void computeReversePostOrder();
155 
156  /// Make the terminator of this block an unconditional branch to \p Target.
157  void makeUnconditional(BasicBlock *BB, BasicBlock *Target);
158 
159 public:
160  AggressiveDeadCodeElimination(Function &F, PostDominatorTree &PDT)
161  : F(F), PDT(PDT) {}
162  bool performDeadCodeElimination();
163 };
164 }
165 
166 bool AggressiveDeadCodeElimination::performDeadCodeElimination() {
167  initialize();
168  markLiveInstructions();
169  return removeDeadInstructions();
170 }
171 
173  auto *BR = dyn_cast<BranchInst>(Term);
174  return BR && BR->isUnconditional();
175 }
176 
178 
179  auto NumBlocks = F.size();
180 
181  // We will have an entry in the map for each block so we grow the
182  // structure to twice that size to keep the load factor low in the hash table.
183  BlockInfo.reserve(NumBlocks);
184  size_t NumInsts = 0;
185 
186  // Iterate over blocks and initialize BlockInfoVec entries, count
187  // instructions to size the InstInfo hash table.
188  for (auto &BB : F) {
189  NumInsts += BB.size();
190  auto &Info = BlockInfo[&BB];
191  Info.BB = &BB;
192  Info.Terminator = BB.getTerminator();
193  Info.UnconditionalBranch = isUnconditionalBranch(Info.Terminator);
194  }
195 
196  // Initialize instruction map and set pointers to block info.
197  InstInfo.reserve(NumInsts);
198  for (auto &BBInfo : BlockInfo)
199  for (Instruction &I : *BBInfo.second.BB)
200  InstInfo[&I].Block = &BBInfo.second;
201 
202  // Since BlockInfoVec holds pointers into InstInfo and vice-versa, we may not
203  // add any more elements to either after this point.
204  for (auto &BBInfo : BlockInfo)
205  BBInfo.second.TerminatorLiveInfo = &InstInfo[BBInfo.second.Terminator];
206 
207  // Collect the set of "root" instructions that are known live.
208  for (Instruction &I : instructions(F))
209  if (isAlwaysLive(I))
210  markLive(&I);
211 
213  return;
214 
215  if (!RemoveLoops) {
216  // This stores state for the depth-first iterator. In addition
217  // to recording which nodes have been visited we also record whether
218  // a node is currently on the "stack" of active ancestors of the current
219  // node.
220  typedef DenseMap<BasicBlock *, bool> StatusMap ;
221  class DFState : public StatusMap {
222  public:
223  std::pair<StatusMap::iterator, bool> insert(BasicBlock *BB) {
224  return StatusMap::insert(std::make_pair(BB, true));
225  }
226 
227  // Invoked after we have visited all children of a node.
228  void completed(BasicBlock *BB) { (*this)[BB] = false; }
229 
230  // Return true if \p BB is currently on the active stack
231  // of ancestors.
232  bool onStack(BasicBlock *BB) {
233  auto Iter = find(BB);
234  return Iter != end() && Iter->second;
235  }
236  } State;
237 
238  State.reserve(F.size());
239  // Iterate over blocks in depth-first pre-order and
240  // treat all edges to a block already seen as loop back edges
241  // and mark the branch live it if there is a back edge.
242  for (auto *BB: depth_first_ext(&F.getEntryBlock(), State)) {
243  TerminatorInst *Term = BB->getTerminator();
244  if (isLive(Term))
245  continue;
246 
247  for (auto *Succ : successors(BB))
248  if (State.onStack(Succ)) {
249  // back edge....
250  markLive(Term);
251  break;
252  }
253  }
254  }
255 
256  // Mark blocks live if there is no path from the block to the
257  // return of the function or a successor for which this is true.
258  // This protects IDFCalculator which cannot handle such blocks.
259  for (auto &BBInfoPair : BlockInfo) {
260  auto &BBInfo = BBInfoPair.second;
261  if (BBInfo.terminatorIsLive())
262  continue;
263  auto *BB = BBInfo.BB;
264  if (!PDT.getNode(BB)) {
265  markLive(BBInfo.Terminator);
266  continue;
267  }
268  for (auto *Succ : successors(BB))
269  if (!PDT.getNode(Succ)) {
270  markLive(BBInfo.Terminator);
271  break;
272  }
273  }
274 
275  // Mark blocks live if there is no path from the block to the
276  // return of the function or a successor for which this is true.
277  // This protects IDFCalculator which cannot handle such blocks.
278  for (auto &BBInfoPair : BlockInfo) {
279  auto &BBInfo = BBInfoPair.second;
280  if (BBInfo.terminatorIsLive())
281  continue;
282  auto *BB = BBInfo.BB;
283  if (!PDT.getNode(BB)) {
284  DEBUG(dbgs() << "Not post-dominated by return: " << BB->getName()
285  << '\n';);
286  markLive(BBInfo.Terminator);
287  continue;
288  }
289  for (auto *Succ : successors(BB))
290  if (!PDT.getNode(Succ)) {
291  DEBUG(dbgs() << "Successor not post-dominated by return: "
292  << BB->getName() << '\n';);
293  markLive(BBInfo.Terminator);
294  break;
295  }
296  }
297 
298  // Treat the entry block as always live
299  auto *BB = &F.getEntryBlock();
300  auto &EntryInfo = BlockInfo[BB];
301  EntryInfo.Live = true;
302  if (EntryInfo.UnconditionalBranch)
303  markLive(EntryInfo.Terminator);
304 
305  // Build initial collection of blocks with dead terminators
306  for (auto &BBInfo : BlockInfo)
307  if (!BBInfo.second.terminatorIsLive())
308  BlocksWithDeadTerminators.insert(BBInfo.second.BB);
309 }
310 
312  // TODO -- use llvm::isInstructionTriviallyDead
313  if (I.isEHPad() || I.mayHaveSideEffects()) {
314  // Skip any value profile instrumentation calls if they are
315  // instrumenting constants.
316  if (isInstrumentsConstant(I))
317  return false;
318  return true;
319  }
320  if (!isa<TerminatorInst>(I))
321  return false;
322  if (RemoveControlFlowFlag && (isa<BranchInst>(I) || isa<SwitchInst>(I)))
323  return false;
324  return true;
325 }
326 
327 // Check if this instruction is a runtime call for value profiling and
328 // if it's instrumenting a constant.
329 bool AggressiveDeadCodeElimination::isInstrumentsConstant(Instruction &I) {
330  // TODO -- move this test into llvm::isInstructionTriviallyDead
331  if (CallInst *CI = dyn_cast<CallInst>(&I))
332  if (Function *Callee = CI->getCalledFunction())
333  if (Callee->getName().equals(getInstrProfValueProfFuncName()))
334  if (isa<Constant>(CI->getArgOperand(0)))
335  return true;
336  return false;
337 }
338 
339 void AggressiveDeadCodeElimination::markLiveInstructions() {
340 
341  // Propagate liveness backwards to operands.
342  do {
343  // Worklist holds newly discovered live instructions
344  // where we need to mark the inputs as live.
345  while (!Worklist.empty()) {
346  Instruction *LiveInst = Worklist.pop_back_val();
347  DEBUG(dbgs() << "work live: "; LiveInst->dump(););
348 
349  for (Use &OI : LiveInst->operands())
350  if (Instruction *Inst = dyn_cast<Instruction>(OI))
351  markLive(Inst);
352 
353  if (auto *PN = dyn_cast<PHINode>(LiveInst))
354  markPhiLive(PN);
355  }
356 
357  // After data flow liveness has been identified, examine which branch
358  // decisions are required to determine live instructions are executed.
359  markLiveBranchesFromControlDependences();
360 
361  } while (!Worklist.empty());
362 }
363 
364 void AggressiveDeadCodeElimination::markLive(Instruction *I) {
365 
366  auto &Info = InstInfo[I];
367  if (Info.Live)
368  return;
369 
370  DEBUG(dbgs() << "mark live: "; I->dump());
371  Info.Live = true;
372  Worklist.push_back(I);
373 
374  // Collect the live debug info scopes attached to this instruction.
375  if (const DILocation *DL = I->getDebugLoc())
376  collectLiveScopes(*DL);
377 
378  // Mark the containing block live
379  auto &BBInfo = *Info.Block;
380  if (BBInfo.Terminator == I) {
381  BlocksWithDeadTerminators.erase(BBInfo.BB);
382  // For live terminators, mark destination blocks
383  // live to preserve this control flow edges.
384  if (!BBInfo.UnconditionalBranch)
385  for (auto *BB : successors(I->getParent()))
386  markLive(BB);
387  }
388  markLive(BBInfo);
389 }
390 
391 void AggressiveDeadCodeElimination::markLive(BlockInfoType &BBInfo) {
392  if (BBInfo.Live)
393  return;
394  DEBUG(dbgs() << "mark block live: " << BBInfo.BB->getName() << '\n');
395  BBInfo.Live = true;
396  if (!BBInfo.CFLive) {
397  BBInfo.CFLive = true;
398  NewLiveBlocks.insert(BBInfo.BB);
399  }
400 
401  // Mark unconditional branches at the end of live
402  // blocks as live since there is no work to do for them later
403  if (BBInfo.UnconditionalBranch)
404  markLive(BBInfo.Terminator);
405 }
406 
407 void AggressiveDeadCodeElimination::collectLiveScopes(const DILocalScope &LS) {
408  if (!AliveScopes.insert(&LS).second)
409  return;
410 
411  if (isa<DISubprogram>(LS))
412  return;
413 
414  // Tail-recurse through the scope chain.
415  collectLiveScopes(cast<DILocalScope>(*LS.getScope()));
416 }
417 
418 void AggressiveDeadCodeElimination::collectLiveScopes(const DILocation &DL) {
419  // Even though DILocations are not scopes, shove them into AliveScopes so we
420  // don't revisit them.
421  if (!AliveScopes.insert(&DL).second)
422  return;
423 
424  // Collect live scopes from the scope chain.
425  collectLiveScopes(*DL.getScope());
426 
427  // Tail-recurse through the inlined-at chain.
428  if (const DILocation *IA = DL.getInlinedAt())
429  collectLiveScopes(*IA);
430 }
431 
432 void AggressiveDeadCodeElimination::markPhiLive(PHINode *PN) {
433  auto &Info = BlockInfo[PN->getParent()];
434  // Only need to check this once per block.
435  if (Info.HasLivePhiNodes)
436  return;
437  Info.HasLivePhiNodes = true;
438 
439  // If a predecessor block is not live, mark it as control-flow live
440  // which will trigger marking live branches upon which
441  // that block is control dependent.
442  for (auto *PredBB : predecessors(Info.BB)) {
443  auto &Info = BlockInfo[PredBB];
444  if (!Info.CFLive) {
445  Info.CFLive = true;
446  NewLiveBlocks.insert(PredBB);
447  }
448  }
449 }
450 
451 void AggressiveDeadCodeElimination::markLiveBranchesFromControlDependences() {
452 
453  if (BlocksWithDeadTerminators.empty())
454  return;
455 
456  DEBUG({
457  dbgs() << "new live blocks:\n";
458  for (auto *BB : NewLiveBlocks)
459  dbgs() << "\t" << BB->getName() << '\n';
460  dbgs() << "dead terminator blocks:\n";
461  for (auto *BB : BlocksWithDeadTerminators)
462  dbgs() << "\t" << BB->getName() << '\n';
463  });
464 
465  // The dominance frontier of a live block X in the reverse
466  // control graph is the set of blocks upon which X is control
467  // dependent. The following sequence computes the set of blocks
468  // which currently have dead terminators that are control
469  // dependence sources of a block which is in NewLiveBlocks.
470 
472  ReverseIDFCalculator IDFs(PDT);
473  IDFs.setDefiningBlocks(NewLiveBlocks);
474  IDFs.setLiveInBlocks(BlocksWithDeadTerminators);
475  IDFs.calculate(IDFBlocks);
476  NewLiveBlocks.clear();
477 
478  // Dead terminators which control live blocks are now marked live.
479  for (auto *BB : IDFBlocks) {
480  DEBUG(dbgs() << "live control in: " << BB->getName() << '\n');
481  markLive(BB->getTerminator());
482  }
483 }
484 
485 //===----------------------------------------------------------------------===//
486 //
487 // Routines to update the CFG and SSA information before removing dead code.
488 //
489 //===----------------------------------------------------------------------===//
490 bool AggressiveDeadCodeElimination::removeDeadInstructions() {
491 
492  // Updates control and dataflow around dead blocks
493  updateDeadRegions();
494 
495  DEBUG({
496  for (Instruction &I : instructions(F)) {
497  // Check if the instruction is alive.
498  if (isLive(&I))
499  continue;
500 
501  if (auto *DII = dyn_cast<DbgInfoIntrinsic>(&I)) {
502  // Check if the scope of this variable location is alive.
503  if (AliveScopes.count(DII->getDebugLoc()->getScope()))
504  continue;
505 
506  // If intrinsic is pointing at a live SSA value, there may be an
507  // earlier optimization bug: if we know the location of the variable,
508  // why isn't the scope of the location alive?
509  if (Value *V = DII->getVariableLocation())
510  if (Instruction *II = dyn_cast<Instruction>(V))
511  if (isLive(II))
512  dbgs() << "Dropping debug info for " << *DII << "\n";
513  }
514  }
515  });
516 
517  // The inverse of the live set is the dead set. These are those instructions
518  // that have no side effects and do not influence the control flow or return
519  // value of the function, and may therefore be deleted safely.
520  // NOTE: We reuse the Worklist vector here for memory efficiency.
521  for (Instruction &I : instructions(F)) {
522  // Check if the instruction is alive.
523  if (isLive(&I))
524  continue;
525 
526  if (auto *DII = dyn_cast<DbgInfoIntrinsic>(&I)) {
527  // Check if the scope of this variable location is alive.
528  if (AliveScopes.count(DII->getDebugLoc()->getScope()))
529  continue;
530 
531  // Fallthrough and drop the intrinsic.
532  }
533 
534  // Prepare to delete.
535  Worklist.push_back(&I);
536  I.dropAllReferences();
537  }
538 
539  for (Instruction *&I : Worklist) {
540  ++NumRemoved;
541  I->eraseFromParent();
542  }
543 
544  return !Worklist.empty();
545 }
546 
547 // A dead region is the set of dead blocks with a common live post-dominator.
548 void AggressiveDeadCodeElimination::updateDeadRegions() {
549 
550  DEBUG({
551  dbgs() << "final dead terminator blocks: " << '\n';
552  for (auto *BB : BlocksWithDeadTerminators)
553  dbgs() << '\t' << BB->getName()
554  << (BlockInfo[BB].Live ? " LIVE\n" : "\n");
555  });
556 
557  // Don't compute the post ordering unless we needed it.
558  bool HavePostOrder = false;
559 
560  for (auto *BB : BlocksWithDeadTerminators) {
561  auto &Info = BlockInfo[BB];
562  if (Info.UnconditionalBranch) {
563  InstInfo[Info.Terminator].Live = true;
564  continue;
565  }
566 
567  if (!HavePostOrder) {
568  computeReversePostOrder();
569  HavePostOrder = true;
570  }
571 
572  // Add an unconditional branch to the successor closest to the
573  // end of the function which insures a path to the exit for each
574  // live edge.
575  BlockInfoType *PreferredSucc = nullptr;
576  for (auto *Succ : successors(BB)) {
577  auto *Info = &BlockInfo[Succ];
578  if (!PreferredSucc || PreferredSucc->PostOrder < Info->PostOrder)
579  PreferredSucc = Info;
580  }
581  assert((PreferredSucc && PreferredSucc->PostOrder > 0) &&
582  "Failed to find safe successor for dead branc");
583  bool First = true;
584  for (auto *Succ : successors(BB)) {
585  if (!First || Succ != PreferredSucc->BB)
586  Succ->removePredecessor(BB);
587  else
588  First = false;
589  }
590  makeUnconditional(BB, PreferredSucc->BB);
591  NumBranchesRemoved += 1;
592  }
593 }
594 
595 // reverse top-sort order
596 void AggressiveDeadCodeElimination::computeReversePostOrder() {
597 
598  // This provides a post-order numbering of the reverse conrtol flow graph
599  // Note that it is incomplete in the presence of infinite loops but we don't
600  // need numbers blocks which don't reach the end of the functions since
601  // all branches in those blocks are forced live.
602 
603  // For each block without successors, extend the DFS from the bloack
604  // backward through the graph
606  unsigned PostOrder = 0;
607  for (auto &BB : F) {
608  if (succ_begin(&BB) != succ_end(&BB))
609  continue;
610  for (BasicBlock *Block : inverse_post_order_ext(&BB,Visited))
611  BlockInfo[Block].PostOrder = PostOrder++;
612  }
613 }
614 
615 void AggressiveDeadCodeElimination::makeUnconditional(BasicBlock *BB,
616  BasicBlock *Target) {
617  TerminatorInst *PredTerm = BB->getTerminator();
618  // Collect the live debug info scopes attached to this instruction.
619  if (const DILocation *DL = PredTerm->getDebugLoc())
620  collectLiveScopes(*DL);
621 
622  // Just mark live an existing unconditional branch
623  if (isUnconditionalBranch(PredTerm)) {
624  PredTerm->setSuccessor(0, Target);
625  InstInfo[PredTerm].Live = true;
626  return;
627  }
628  DEBUG(dbgs() << "making unconditional " << BB->getName() << '\n');
629  NumBranchesRemoved += 1;
630  IRBuilder<> Builder(PredTerm);
631  auto *NewTerm = Builder.CreateBr(Target);
632  InstInfo[NewTerm].Live = true;
633  if (const DILocation *DL = PredTerm->getDebugLoc())
634  NewTerm->setDebugLoc(DL);
635 }
636 
637 //===----------------------------------------------------------------------===//
638 //
639 // Pass Manager integration code
640 //
641 //===----------------------------------------------------------------------===//
643  auto &PDT = FAM.getResult<PostDominatorTreeAnalysis>(F);
644  if (!AggressiveDeadCodeElimination(F, PDT).performDeadCodeElimination())
645  return PreservedAnalyses::all();
646 
647  // FIXME: This should also 'preserve the CFG'.
648  auto PA = PreservedAnalyses();
649  PA.preserve<GlobalsAA>();
650  return PA;
651 }
652 
653 namespace {
654 struct ADCELegacyPass : public FunctionPass {
655  static char ID; // Pass identification, replacement for typeid
656  ADCELegacyPass() : FunctionPass(ID) {
658  }
659 
660  bool runOnFunction(Function &F) override {
661  if (skipFunction(F))
662  return false;
663  auto &PDT = getAnalysis<PostDominatorTreeWrapperPass>().getPostDomTree();
664  return AggressiveDeadCodeElimination(F, PDT).performDeadCodeElimination();
665  }
666 
667  void getAnalysisUsage(AnalysisUsage &AU) const override {
670  AU.setPreservesCFG();
672  }
673 };
674 }
675 
676 char ADCELegacyPass::ID = 0;
677 INITIALIZE_PASS_BEGIN(ADCELegacyPass, "adce",
678  "Aggressive Dead Code Elimination", false, false)
681  false, false)
682 
683 FunctionPass *llvm::createAggressiveDCEPass() { return new ADCELegacyPass(); }
Legacy wrapper pass to provide the GlobalsAAResult object.
SymbolTableList< Instruction >::iterator eraseFromParent()
This method unlinks 'this' from the containing basic block and deletes it.
Definition: Instruction.cpp:76
const_iterator end(StringRef path)
Get end iterator over path.
Definition: Path.cpp:241
AnalysisUsage & addPreserved()
Add the specified Pass class to the set of analyses preserved by this pass.
static PassRegistry * getPassRegistry()
getPassRegistry - Access the global registry object, which is automatically initialized at applicatio...
void dropAllReferences()
Drop all references to operands.
Definition: User.h:269
Aggressive Dead Code Elimination
Definition: ADCE.cpp:680
STATISTIC(NumFunctions,"Total number of functions")
This is the interface for a simple mod/ref and alias analysis over globals.
adce
Definition: ADCE.cpp:680
static cl::opt< bool > RemoveControlFlowFlag("adce-remove-control-flow", cl::init(true), cl::Hidden)
This class represents a function call, abstracting a target machine's calling convention.
bool mayHaveSideEffects() const
Return true if the instruction may have side effects.
Definition: Instruction.h:450
static cl::opt< bool > RemoveLoops("adce-remove-loops", cl::init(false), cl::Hidden)
A scope for locals.
StringRef getName() const
Return a constant reference to the value's name.
Definition: Value.cpp:191
Aggressive Dead Code false
Definition: ADCE.cpp:680
AnalysisUsage & addRequired()
#define INITIALIZE_PASS_DEPENDENCY(depName)
Definition: PassSupport.h:53
void initializeADCELegacyPassPass(PassRegistry &)
static cl::opt< bool > Aggressive("aggressive-ext-opt", cl::Hidden, cl::desc("Aggressive extension optimization"))
A Use represents the edge between a Value definition and its users.
Definition: Use.h:56
This provides a uniform API for creating instructions and inserting them into a basic block: either a...
Definition: IRBuilder.h:588
Interval::succ_iterator succ_begin(Interval *I)
succ_begin/succ_end - define methods so that Intervals may be used just like BasicBlocks can with the...
Definition: Interval.h:106
#define F(x, y, z)
Definition: MD5.cpp:51
DIScopeRef getScope() const
void setSuccessor(unsigned idx, BasicBlock *B)
Update the specified successor to point at the provided block.
Definition: InstrTypes.h:84
Debug location.
Interval::succ_iterator succ_end(Interval *I)
Definition: Interval.h:109
initializer< Ty > init(const Ty &Val)
Definition: CommandLine.h:395
Control flow instructions. These all have token chains.
Definition: ISDOpcodes.h:551
Subclasses of this class are all able to terminate a basic block.
Definition: InstrTypes.h:52
A set of analyses that are preserved following a run of a transformation pass.
Definition: PassManager.h:107
PassT::Result & getResult(IRUnitT &IR, ExtraArgTs...ExtraArgs)
Get the result of an analysis pass for a given IR unit.
Definition: PassManager.h:653
LLVM Basic Block Representation.
Definition: BasicBlock.h:51
Conditional or Unconditional Branch instruction.
StringRef getInstrProfValueProfFuncName()
Return the name profile runtime entry point to do value profiling for a given site.
Definition: InstrProf.h:78
const DebugLoc & getDebugLoc() const
Return the debug location for this node as a DebugLoc.
Definition: Instruction.h:259
iterator_range< df_ext_iterator< T, SetTy > > depth_first_ext(const T &G, SetTy &S)
Represent the analysis usage information of a pass.
Analysis pass providing a never-invalidated alias analysis result.
INITIALIZE_PASS_END(RegBankSelect, DEBUG_TYPE,"Assign register bank of generic virtual registers", false, false) RegBankSelect
FunctionPass class - This class is used to implement most global optimizations.
Definition: Pass.h:298
op_range operands()
Definition: User.h:213
static PreservedAnalyses all()
Construct a special preserved set that preserves all passes.
Definition: PassManager.h:113
PreservedAnalyses run(Function &F, FunctionAnalysisManager &)
Definition: ADCE.cpp:642
void dump() const
Support for debugging, callable in GDB: V->dump()
Definition: AsmWriter.cpp:3540
SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements...
Definition: SmallPtrSet.h:425
auto find(R &&Range, const T &Val) -> decltype(std::begin(Range))
Provide wrappers to std::find which take ranges instead of having to pass begin/end explicitly...
Definition: STLExtras.h:757
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:843
Analysis pass which computes a PostDominatorTree.
pred_range predecessors(BasicBlock *BB)
Definition: IR/CFG.h:110
void setPreservesCFG()
This function should be called by the pass, iff they do not:
Definition: Pass.cpp:276
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:132
Target - Wrapper for Target specific information.
static void initialize(TargetLibraryInfoImpl &TLI, const Triple &T, ArrayRef< StringRef > StandardNames)
initialize - Initialize the set of available library functions based on the specified target triple...
static bool isUnconditionalBranch(TerminatorInst *Term)
Definition: ADCE.cpp:172
PostDominatorTree Class - Concrete subclass of DominatorTree that is used to compute the post-dominat...
iterator_range< ipo_ext_iterator< T, SetType > > inverse_post_order_ext(const T &G, SetType &S)
bool isEHPad() const
Return true if the instruction is a variety of EH-block.
Definition: Instruction.h:453
#define I(x, y, z)
Definition: MD5.cpp:54
TerminatorInst * getTerminator()
Returns the terminator instruction if the block is well formed or null if the block is not well forme...
Definition: BasicBlock.cpp:124
LLVM_NODISCARD std::enable_if<!is_simple_type< Y >::value, typename cast_retty< X, const Y >::ret_type >::type dyn_cast(const Y &Val)
Definition: Casting.h:287
Determine the iterated dominance frontier, given a set of defining blocks, and optionally, a set of live-in blocks.
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
LLVM Value Representation.
Definition: Value.h:71
succ_range successors(BasicBlock *BB)
Definition: IR/CFG.h:143
static bool isAlwaysLive(Instruction *I)
#define DEBUG(X)
Definition: Debug.h:100
INITIALIZE_PASS_BEGIN(ADCELegacyPass,"adce","Aggressive Dead Code Elimination", false, false) INITIALIZE_PASS_END(ADCELegacyPass
inst_range instructions(Function *F)
Definition: InstIterator.h:132
A container for analyses that lazily runs them and caches their results.
const BasicBlock * getParent() const
Definition: Instruction.h:62
FunctionPass * createAggressiveDCEPass()
Definition: ADCE.cpp:683