LLVM  3.7.0
Local.cpp
Go to the documentation of this file.
1 //===-- Local.cpp - Functions to perform local transformations ------------===//
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 family of functions perform various local transformations to the
11 // program.
12 //
13 //===----------------------------------------------------------------------===//
14 
16 #include "llvm/ADT/DenseMap.h"
17 #include "llvm/ADT/DenseSet.h"
18 #include "llvm/ADT/Hashing.h"
19 #include "llvm/ADT/STLExtras.h"
20 #include "llvm/ADT/SmallPtrSet.h"
21 #include "llvm/ADT/Statistic.h"
26 #include "llvm/IR/CFG.h"
27 #include "llvm/IR/Constants.h"
28 #include "llvm/IR/DIBuilder.h"
29 #include "llvm/IR/DataLayout.h"
30 #include "llvm/IR/DebugInfo.h"
31 #include "llvm/IR/DerivedTypes.h"
32 #include "llvm/IR/Dominators.h"
34 #include "llvm/IR/GlobalAlias.h"
35 #include "llvm/IR/GlobalVariable.h"
36 #include "llvm/IR/IRBuilder.h"
37 #include "llvm/IR/Instructions.h"
38 #include "llvm/IR/IntrinsicInst.h"
39 #include "llvm/IR/Intrinsics.h"
40 #include "llvm/IR/MDBuilder.h"
41 #include "llvm/IR/Metadata.h"
42 #include "llvm/IR/Operator.h"
43 #include "llvm/IR/ValueHandle.h"
44 #include "llvm/Support/Debug.h"
47 using namespace llvm;
48 
49 #define DEBUG_TYPE "local"
50 
51 STATISTIC(NumRemoved, "Number of unreachable basic blocks removed");
52 
53 //===----------------------------------------------------------------------===//
54 // Local constant propagation.
55 //
56 
57 /// ConstantFoldTerminator - If a terminator instruction is predicated on a
58 /// constant value, convert it into an unconditional branch to the constant
59 /// destination. This is a nontrivial operation because the successors of this
60 /// basic block must have their PHI nodes updated.
61 /// Also calls RecursivelyDeleteTriviallyDeadInstructions() on any branch/switch
62 /// conditions and indirectbr addresses this might make dead if
63 /// DeleteDeadConditions is true.
64 bool llvm::ConstantFoldTerminator(BasicBlock *BB, bool DeleteDeadConditions,
65  const TargetLibraryInfo *TLI) {
67  IRBuilder<> Builder(T);
68 
69  // Branch - See if we are conditional jumping on constant
70  if (BranchInst *BI = dyn_cast<BranchInst>(T)) {
71  if (BI->isUnconditional()) return false; // Can't optimize uncond branch
72  BasicBlock *Dest1 = BI->getSuccessor(0);
73  BasicBlock *Dest2 = BI->getSuccessor(1);
74 
75  if (ConstantInt *Cond = dyn_cast<ConstantInt>(BI->getCondition())) {
76  // Are we branching on constant?
77  // YES. Change to unconditional branch...
78  BasicBlock *Destination = Cond->getZExtValue() ? Dest1 : Dest2;
79  BasicBlock *OldDest = Cond->getZExtValue() ? Dest2 : Dest1;
80 
81  //cerr << "Function: " << T->getParent()->getParent()
82  // << "\nRemoving branch from " << T->getParent()
83  // << "\n\nTo: " << OldDest << endl;
84 
85  // Let the basic block know that we are letting go of it. Based on this,
86  // it will adjust it's PHI nodes.
87  OldDest->removePredecessor(BB);
88 
89  // Replace the conditional branch with an unconditional one.
90  Builder.CreateBr(Destination);
91  BI->eraseFromParent();
92  return true;
93  }
94 
95  if (Dest2 == Dest1) { // Conditional branch to same location?
96  // This branch matches something like this:
97  // br bool %cond, label %Dest, label %Dest
98  // and changes it into: br label %Dest
99 
100  // Let the basic block know that we are letting go of one copy of it.
101  assert(BI->getParent() && "Terminator not inserted in block!");
102  Dest1->removePredecessor(BI->getParent());
103 
104  // Replace the conditional branch with an unconditional one.
105  Builder.CreateBr(Dest1);
106  Value *Cond = BI->getCondition();
107  BI->eraseFromParent();
108  if (DeleteDeadConditions)
110  return true;
111  }
112  return false;
113  }
114 
115  if (SwitchInst *SI = dyn_cast<SwitchInst>(T)) {
116  // If we are switching on a constant, we can convert the switch to an
117  // unconditional branch.
118  ConstantInt *CI = dyn_cast<ConstantInt>(SI->getCondition());
119  BasicBlock *DefaultDest = SI->getDefaultDest();
120  BasicBlock *TheOnlyDest = DefaultDest;
121 
122  // If the default is unreachable, ignore it when searching for TheOnlyDest.
123  if (isa<UnreachableInst>(DefaultDest->getFirstNonPHIOrDbg()) &&
124  SI->getNumCases() > 0) {
125  TheOnlyDest = SI->case_begin().getCaseSuccessor();
126  }
127 
128  // Figure out which case it goes to.
129  for (SwitchInst::CaseIt i = SI->case_begin(), e = SI->case_end();
130  i != e; ++i) {
131  // Found case matching a constant operand?
132  if (i.getCaseValue() == CI) {
133  TheOnlyDest = i.getCaseSuccessor();
134  break;
135  }
136 
137  // Check to see if this branch is going to the same place as the default
138  // dest. If so, eliminate it as an explicit compare.
139  if (i.getCaseSuccessor() == DefaultDest) {
140  MDNode *MD = SI->getMetadata(LLVMContext::MD_prof);
141  unsigned NCases = SI->getNumCases();
142  // Fold the case metadata into the default if there will be any branches
143  // left, unless the metadata doesn't match the switch.
144  if (NCases > 1 && MD && MD->getNumOperands() == 2 + NCases) {
145  // Collect branch weights into a vector.
146  SmallVector<uint32_t, 8> Weights;
147  for (unsigned MD_i = 1, MD_e = MD->getNumOperands(); MD_i < MD_e;
148  ++MD_i) {
149  ConstantInt *CI =
150  mdconst::dyn_extract<ConstantInt>(MD->getOperand(MD_i));
151  assert(CI);
152  Weights.push_back(CI->getValue().getZExtValue());
153  }
154  // Merge weight of this case to the default weight.
155  unsigned idx = i.getCaseIndex();
156  Weights[0] += Weights[idx+1];
157  // Remove weight for this case.
158  std::swap(Weights[idx+1], Weights.back());
159  Weights.pop_back();
160  SI->setMetadata(LLVMContext::MD_prof,
161  MDBuilder(BB->getContext()).
162  createBranchWeights(Weights));
163  }
164  // Remove this entry.
165  DefaultDest->removePredecessor(SI->getParent());
166  SI->removeCase(i);
167  --i; --e;
168  continue;
169  }
170 
171  // Otherwise, check to see if the switch only branches to one destination.
172  // We do this by reseting "TheOnlyDest" to null when we find two non-equal
173  // destinations.
174  if (i.getCaseSuccessor() != TheOnlyDest) TheOnlyDest = nullptr;
175  }
176 
177  if (CI && !TheOnlyDest) {
178  // Branching on a constant, but not any of the cases, go to the default
179  // successor.
180  TheOnlyDest = SI->getDefaultDest();
181  }
182 
183  // If we found a single destination that we can fold the switch into, do so
184  // now.
185  if (TheOnlyDest) {
186  // Insert the new branch.
187  Builder.CreateBr(TheOnlyDest);
188  BasicBlock *BB = SI->getParent();
189 
190  // Remove entries from PHI nodes which we no longer branch to...
191  for (unsigned i = 0, e = SI->getNumSuccessors(); i != e; ++i) {
192  // Found case matching a constant operand?
193  BasicBlock *Succ = SI->getSuccessor(i);
194  if (Succ == TheOnlyDest)
195  TheOnlyDest = nullptr; // Don't modify the first branch to TheOnlyDest
196  else
197  Succ->removePredecessor(BB);
198  }
199 
200  // Delete the old switch.
201  Value *Cond = SI->getCondition();
202  SI->eraseFromParent();
203  if (DeleteDeadConditions)
205  return true;
206  }
207 
208  if (SI->getNumCases() == 1) {
209  // Otherwise, we can fold this switch into a conditional branch
210  // instruction if it has only one non-default destination.
211  SwitchInst::CaseIt FirstCase = SI->case_begin();
212  Value *Cond = Builder.CreateICmpEQ(SI->getCondition(),
213  FirstCase.getCaseValue(), "cond");
214 
215  // Insert the new branch.
216  BranchInst *NewBr = Builder.CreateCondBr(Cond,
217  FirstCase.getCaseSuccessor(),
218  SI->getDefaultDest());
219  MDNode *MD = SI->getMetadata(LLVMContext::MD_prof);
220  if (MD && MD->getNumOperands() == 3) {
221  ConstantInt *SICase =
222  mdconst::dyn_extract<ConstantInt>(MD->getOperand(2));
223  ConstantInt *SIDef =
224  mdconst::dyn_extract<ConstantInt>(MD->getOperand(1));
225  assert(SICase && SIDef);
226  // The TrueWeight should be the weight for the single case of SI.
228  MDBuilder(BB->getContext()).
229  createBranchWeights(SICase->getValue().getZExtValue(),
230  SIDef->getValue().getZExtValue()));
231  }
232 
233  // Delete the old switch.
234  SI->eraseFromParent();
235  return true;
236  }
237  return false;
238  }
239 
240  if (IndirectBrInst *IBI = dyn_cast<IndirectBrInst>(T)) {
241  // indirectbr blockaddress(@F, @BB) -> br label @BB
242  if (BlockAddress *BA =
243  dyn_cast<BlockAddress>(IBI->getAddress()->stripPointerCasts())) {
244  BasicBlock *TheOnlyDest = BA->getBasicBlock();
245  // Insert the new branch.
246  Builder.CreateBr(TheOnlyDest);
247 
248  for (unsigned i = 0, e = IBI->getNumDestinations(); i != e; ++i) {
249  if (IBI->getDestination(i) == TheOnlyDest)
250  TheOnlyDest = nullptr;
251  else
252  IBI->getDestination(i)->removePredecessor(IBI->getParent());
253  }
254  Value *Address = IBI->getAddress();
255  IBI->eraseFromParent();
256  if (DeleteDeadConditions)
258 
259  // If we didn't find our destination in the IBI successor list, then we
260  // have undefined behavior. Replace the unconditional branch with an
261  // 'unreachable' instruction.
262  if (TheOnlyDest) {
264  new UnreachableInst(BB->getContext(), BB);
265  }
266 
267  return true;
268  }
269  }
270 
271  return false;
272 }
273 
274 
275 //===----------------------------------------------------------------------===//
276 // Local dead code elimination.
277 //
278 
279 /// isInstructionTriviallyDead - Return true if the result produced by the
280 /// instruction is not used, and the instruction has no side effects.
281 ///
283  const TargetLibraryInfo *TLI) {
284  if (!I->use_empty() || isa<TerminatorInst>(I)) return false;
285 
286  // We don't want the landingpad instruction removed by anything this general.
287  if (isa<LandingPadInst>(I))
288  return false;
289 
290  // We don't want debug info removed by anything this general, unless
291  // debug info is empty.
292  if (DbgDeclareInst *DDI = dyn_cast<DbgDeclareInst>(I)) {
293  if (DDI->getAddress())
294  return false;
295  return true;
296  }
297  if (DbgValueInst *DVI = dyn_cast<DbgValueInst>(I)) {
298  if (DVI->getValue())
299  return false;
300  return true;
301  }
302 
303  if (!I->mayHaveSideEffects()) return true;
304 
305  // Special case intrinsics that "may have side effects" but can be deleted
306  // when dead.
307  if (IntrinsicInst *II = dyn_cast<IntrinsicInst>(I)) {
308  // Safe to delete llvm.stacksave if dead.
309  if (II->getIntrinsicID() == Intrinsic::stacksave)
310  return true;
311 
312  // Lifetime intrinsics are dead when their right-hand is undef.
313  if (II->getIntrinsicID() == Intrinsic::lifetime_start ||
314  II->getIntrinsicID() == Intrinsic::lifetime_end)
315  return isa<UndefValue>(II->getArgOperand(1));
316 
317  // Assumptions are dead if their condition is trivially true.
318  if (II->getIntrinsicID() == Intrinsic::assume) {
319  if (ConstantInt *Cond = dyn_cast<ConstantInt>(II->getArgOperand(0)))
320  return !Cond->isZero();
321 
322  return false;
323  }
324  }
325 
326  if (isAllocLikeFn(I, TLI)) return true;
327 
328  if (CallInst *CI = isFreeCall(I, TLI))
329  if (Constant *C = dyn_cast<Constant>(CI->getArgOperand(0)))
330  return C->isNullValue() || isa<UndefValue>(C);
331 
332  return false;
333 }
334 
335 /// RecursivelyDeleteTriviallyDeadInstructions - If the specified value is a
336 /// trivially dead instruction, delete it. If that makes any of its operands
337 /// trivially dead, delete them too, recursively. Return true if any
338 /// instructions were deleted.
339 bool
341  const TargetLibraryInfo *TLI) {
343  if (!I || !I->use_empty() || !isInstructionTriviallyDead(I, TLI))
344  return false;
345 
347  DeadInsts.push_back(I);
348 
349  do {
350  I = DeadInsts.pop_back_val();
351 
352  // Null out all of the instruction's operands to see if any operand becomes
353  // dead as we go.
354  for (unsigned i = 0, e = I->getNumOperands(); i != e; ++i) {
355  Value *OpV = I->getOperand(i);
356  I->setOperand(i, nullptr);
357 
358  if (!OpV->use_empty()) continue;
359 
360  // If the operand is an instruction that became dead as we nulled out the
361  // operand, and if it is 'trivially' dead, delete it in a future loop
362  // iteration.
363  if (Instruction *OpI = dyn_cast<Instruction>(OpV))
364  if (isInstructionTriviallyDead(OpI, TLI))
365  DeadInsts.push_back(OpI);
366  }
367 
368  I->eraseFromParent();
369  } while (!DeadInsts.empty());
370 
371  return true;
372 }
373 
374 /// areAllUsesEqual - Check whether the uses of a value are all the same.
375 /// This is similar to Instruction::hasOneUse() except this will also return
376 /// true when there are no uses or multiple uses that all refer to the same
377 /// value.
380  Value::user_iterator UE = I->user_end();
381  if (UI == UE)
382  return true;
383 
384  User *TheUse = *UI;
385  for (++UI; UI != UE; ++UI) {
386  if (*UI != TheUse)
387  return false;
388  }
389  return true;
390 }
391 
392 /// RecursivelyDeleteDeadPHINode - If the specified value is an effectively
393 /// dead PHI node, due to being a def-use chain of single-use nodes that
394 /// either forms a cycle or is terminated by a trivially dead instruction,
395 /// delete it. If that makes any of its operands trivially dead, delete them
396 /// too, recursively. Return true if a change was made.
398  const TargetLibraryInfo *TLI) {
400  for (Instruction *I = PN; areAllUsesEqual(I) && !I->mayHaveSideEffects();
401  I = cast<Instruction>(*I->user_begin())) {
402  if (I->use_empty())
404 
405  // If we find an instruction more than once, we're on a cycle that
406  // won't prove fruitful.
407  if (!Visited.insert(I).second) {
408  // Break the cycle and delete the instruction and its operands.
409  I->replaceAllUsesWith(UndefValue::get(I->getType()));
411  return true;
412  }
413  }
414  return false;
415 }
416 
417 /// SimplifyInstructionsInBlock - Scan the specified basic block and try to
418 /// simplify any instructions in it and recursively delete dead instructions.
419 ///
420 /// This returns true if it changed the code, note that it can delete
421 /// instructions in other blocks as well in this block.
423  const TargetLibraryInfo *TLI) {
424  bool MadeChange = false;
425 
426 #ifndef NDEBUG
427  // In debug builds, ensure that the terminator of the block is never replaced
428  // or deleted by these simplifications. The idea of simplification is that it
429  // cannot introduce new instructions, and there is no way to replace the
430  // terminator of a block without introducing a new instruction.
431  AssertingVH<Instruction> TerminatorVH(--BB->end());
432 #endif
433 
434  for (BasicBlock::iterator BI = BB->begin(), E = --BB->end(); BI != E; ) {
435  assert(!BI->isTerminator());
436  Instruction *Inst = BI++;
437 
438  WeakVH BIHandle(BI);
439  if (recursivelySimplifyInstruction(Inst, TLI)) {
440  MadeChange = true;
441  if (BIHandle != BI)
442  BI = BB->begin();
443  continue;
444  }
445 
446  MadeChange |= RecursivelyDeleteTriviallyDeadInstructions(Inst, TLI);
447  if (BIHandle != BI)
448  BI = BB->begin();
449  }
450  return MadeChange;
451 }
452 
453 //===----------------------------------------------------------------------===//
454 // Control Flow Graph Restructuring.
455 //
456 
457 
458 /// RemovePredecessorAndSimplify - Like BasicBlock::removePredecessor, this
459 /// method is called when we're about to delete Pred as a predecessor of BB. If
460 /// BB contains any PHI nodes, this drops the entries in the PHI nodes for Pred.
461 ///
462 /// Unlike the removePredecessor method, this attempts to simplify uses of PHI
463 /// nodes that collapse into identity values. For example, if we have:
464 /// x = phi(1, 0, 0, 0)
465 /// y = and x, z
466 ///
467 /// .. and delete the predecessor corresponding to the '1', this will attempt to
468 /// recursively fold the and to 0.
470  // This only adjusts blocks with PHI nodes.
471  if (!isa<PHINode>(BB->begin()))
472  return;
473 
474  // Remove the entries for Pred from the PHI nodes in BB, but do not simplify
475  // them down. This will leave us with single entry phi nodes and other phis
476  // that can be removed.
477  BB->removePredecessor(Pred, true);
478 
479  WeakVH PhiIt = &BB->front();
480  while (PHINode *PN = dyn_cast<PHINode>(PhiIt)) {
481  PhiIt = &*++BasicBlock::iterator(cast<Instruction>(PhiIt));
482  Value *OldPhiIt = PhiIt;
483 
485  continue;
486 
487  // If recursive simplification ended up deleting the next PHI node we would
488  // iterate to, then our iterator is invalid, restart scanning from the top
489  // of the block.
490  if (PhiIt != OldPhiIt) PhiIt = &BB->front();
491  }
492 }
493 
494 
495 /// MergeBasicBlockIntoOnlyPred - DestBB is a block with one predecessor and its
496 /// predecessor is known to have one successor (DestBB!). Eliminate the edge
497 /// between them, moving the instructions in the predecessor into DestBB and
498 /// deleting the predecessor block.
499 ///
501  // If BB has single-entry PHI nodes, fold them.
502  while (PHINode *PN = dyn_cast<PHINode>(DestBB->begin())) {
503  Value *NewVal = PN->getIncomingValue(0);
504  // Replace self referencing PHI with undef, it must be dead.
505  if (NewVal == PN) NewVal = UndefValue::get(PN->getType());
506  PN->replaceAllUsesWith(NewVal);
507  PN->eraseFromParent();
508  }
509 
510  BasicBlock *PredBB = DestBB->getSinglePredecessor();
511  assert(PredBB && "Block doesn't have a single predecessor!");
512 
513  // Zap anything that took the address of DestBB. Not doing this will give the
514  // address an invalid value.
515  if (DestBB->hasAddressTaken()) {
516  BlockAddress *BA = BlockAddress::get(DestBB);
517  Constant *Replacement =
520  BA->getType()));
521  BA->destroyConstant();
522  }
523 
524  // Anything that branched to PredBB now branches to DestBB.
525  PredBB->replaceAllUsesWith(DestBB);
526 
527  // Splice all the instructions from PredBB to DestBB.
528  PredBB->getTerminator()->eraseFromParent();
529  DestBB->getInstList().splice(DestBB->begin(), PredBB->getInstList());
530 
531  // If the PredBB is the entry block of the function, move DestBB up to
532  // become the entry block after we erase PredBB.
533  if (PredBB == &DestBB->getParent()->getEntryBlock())
534  DestBB->moveAfter(PredBB);
535 
536  if (DT) {
537  BasicBlock *PredBBIDom = DT->getNode(PredBB)->getIDom()->getBlock();
538  DT->changeImmediateDominator(DestBB, PredBBIDom);
539  DT->eraseNode(PredBB);
540  }
541  // Nuke BB.
542  PredBB->eraseFromParent();
543 }
544 
545 /// CanMergeValues - Return true if we can choose one of these values to use
546 /// in place of the other. Note that we will always choose the non-undef
547 /// value to keep.
548 static bool CanMergeValues(Value *First, Value *Second) {
549  return First == Second || isa<UndefValue>(First) || isa<UndefValue>(Second);
550 }
551 
552 /// CanPropagatePredecessorsForPHIs - Return true if we can fold BB, an
553 /// almost-empty BB ending in an unconditional branch to Succ, into Succ.
554 ///
555 /// Assumption: Succ is the single successor for BB.
556 ///
558  assert(*succ_begin(BB) == Succ && "Succ is not successor of BB!");
559 
560  DEBUG(dbgs() << "Looking to fold " << BB->getName() << " into "
561  << Succ->getName() << "\n");
562  // Shortcut, if there is only a single predecessor it must be BB and merging
563  // is always safe
564  if (Succ->getSinglePredecessor()) return true;
565 
566  // Make a list of the predecessors of BB
568 
569  // Look at all the phi nodes in Succ, to see if they present a conflict when
570  // merging these blocks
571  for (BasicBlock::iterator I = Succ->begin(); isa<PHINode>(I); ++I) {
572  PHINode *PN = cast<PHINode>(I);
573 
574  // If the incoming value from BB is again a PHINode in
575  // BB which has the same incoming value for *PI as PN does, we can
576  // merge the phi nodes and then the blocks can still be merged
578  if (BBPN && BBPN->getParent() == BB) {
579  for (unsigned PI = 0, PE = PN->getNumIncomingValues(); PI != PE; ++PI) {
580  BasicBlock *IBB = PN->getIncomingBlock(PI);
581  if (BBPreds.count(IBB) &&
582  !CanMergeValues(BBPN->getIncomingValueForBlock(IBB),
583  PN->getIncomingValue(PI))) {
584  DEBUG(dbgs() << "Can't fold, phi node " << PN->getName() << " in "
585  << Succ->getName() << " is conflicting with "
586  << BBPN->getName() << " with regard to common predecessor "
587  << IBB->getName() << "\n");
588  return false;
589  }
590  }
591  } else {
592  Value* Val = PN->getIncomingValueForBlock(BB);
593  for (unsigned PI = 0, PE = PN->getNumIncomingValues(); PI != PE; ++PI) {
594  // See if the incoming value for the common predecessor is equal to the
595  // one for BB, in which case this phi node will not prevent the merging
596  // of the block.
597  BasicBlock *IBB = PN->getIncomingBlock(PI);
598  if (BBPreds.count(IBB) &&
599  !CanMergeValues(Val, PN->getIncomingValue(PI))) {
600  DEBUG(dbgs() << "Can't fold, phi node " << PN->getName() << " in "
601  << Succ->getName() << " is conflicting with regard to common "
602  << "predecessor " << IBB->getName() << "\n");
603  return false;
604  }
605  }
606  }
607  }
608 
609  return true;
610 }
611 
614 
615 /// \brief Determines the value to use as the phi node input for a block.
616 ///
617 /// Select between \p OldVal any value that we know flows from \p BB
618 /// to a particular phi on the basis of which one (if either) is not
619 /// undef. Update IncomingValues based on the selected value.
620 ///
621 /// \param OldVal The value we are considering selecting.
622 /// \param BB The block that the value flows in from.
623 /// \param IncomingValues A map from block-to-value for other phi inputs
624 /// that we have examined.
625 ///
626 /// \returns the selected value.
628  IncomingValueMap &IncomingValues) {
629  if (!isa<UndefValue>(OldVal)) {
630  assert((!IncomingValues.count(BB) ||
631  IncomingValues.find(BB)->second == OldVal) &&
632  "Expected OldVal to match incoming value from BB!");
633 
634  IncomingValues.insert(std::make_pair(BB, OldVal));
635  return OldVal;
636  }
637 
638  IncomingValueMap::const_iterator It = IncomingValues.find(BB);
639  if (It != IncomingValues.end()) return It->second;
640 
641  return OldVal;
642 }
643 
644 /// \brief Create a map from block to value for the operands of a
645 /// given phi.
646 ///
647 /// Create a map from block to value for each non-undef value flowing
648 /// into \p PN.
649 ///
650 /// \param PN The phi we are collecting the map for.
651 /// \param IncomingValues [out] The map from block to value for this phi.
653  IncomingValueMap &IncomingValues) {
654  for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i) {
655  BasicBlock *BB = PN->getIncomingBlock(i);
656  Value *V = PN->getIncomingValue(i);
657 
658  if (!isa<UndefValue>(V))
659  IncomingValues.insert(std::make_pair(BB, V));
660  }
661 }
662 
663 /// \brief Replace the incoming undef values to a phi with the values
664 /// from a block-to-value map.
665 ///
666 /// \param PN The phi we are replacing the undefs in.
667 /// \param IncomingValues A map from block to value.
669  const IncomingValueMap &IncomingValues) {
670  for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i) {
671  Value *V = PN->getIncomingValue(i);
672 
673  if (!isa<UndefValue>(V)) continue;
674 
675  BasicBlock *BB = PN->getIncomingBlock(i);
676  IncomingValueMap::const_iterator It = IncomingValues.find(BB);
677  if (It == IncomingValues.end()) continue;
678 
679  PN->setIncomingValue(i, It->second);
680  }
681 }
682 
683 /// \brief Replace a value flowing from a block to a phi with
684 /// potentially multiple instances of that value flowing from the
685 /// block's predecessors to the phi.
686 ///
687 /// \param BB The block with the value flowing into the phi.
688 /// \param BBPreds The predecessors of BB.
689 /// \param PN The phi that we are updating.
691  const PredBlockVector &BBPreds,
692  PHINode *PN) {
693  Value *OldVal = PN->removeIncomingValue(BB, false);
694  assert(OldVal && "No entry in PHI for Pred BB!");
695 
696  IncomingValueMap IncomingValues;
697 
698  // We are merging two blocks - BB, and the block containing PN - and
699  // as a result we need to redirect edges from the predecessors of BB
700  // to go to the block containing PN, and update PN
701  // accordingly. Since we allow merging blocks in the case where the
702  // predecessor and successor blocks both share some predecessors,
703  // and where some of those common predecessors might have undef
704  // values flowing into PN, we want to rewrite those values to be
705  // consistent with the non-undef values.
706 
707  gatherIncomingValuesToPhi(PN, IncomingValues);
708 
709  // If this incoming value is one of the PHI nodes in BB, the new entries
710  // in the PHI node are the entries from the old PHI.
711  if (isa<PHINode>(OldVal) && cast<PHINode>(OldVal)->getParent() == BB) {
712  PHINode *OldValPN = cast<PHINode>(OldVal);
713  for (unsigned i = 0, e = OldValPN->getNumIncomingValues(); i != e; ++i) {
714  // Note that, since we are merging phi nodes and BB and Succ might
715  // have common predecessors, we could end up with a phi node with
716  // identical incoming branches. This will be cleaned up later (and
717  // will trigger asserts if we try to clean it up now, without also
718  // simplifying the corresponding conditional branch).
719  BasicBlock *PredBB = OldValPN->getIncomingBlock(i);
720  Value *PredVal = OldValPN->getIncomingValue(i);
721  Value *Selected = selectIncomingValueForBlock(PredVal, PredBB,
722  IncomingValues);
723 
724  // And add a new incoming value for this predecessor for the
725  // newly retargeted branch.
726  PN->addIncoming(Selected, PredBB);
727  }
728  } else {
729  for (unsigned i = 0, e = BBPreds.size(); i != e; ++i) {
730  // Update existing incoming values in PN for this
731  // predecessor of BB.
732  BasicBlock *PredBB = BBPreds[i];
733  Value *Selected = selectIncomingValueForBlock(OldVal, PredBB,
734  IncomingValues);
735 
736  // And add a new incoming value for this predecessor for the
737  // newly retargeted branch.
738  PN->addIncoming(Selected, PredBB);
739  }
740  }
741 
742  replaceUndefValuesInPhi(PN, IncomingValues);
743 }
744 
745 /// TryToSimplifyUncondBranchFromEmptyBlock - BB is known to contain an
746 /// unconditional branch, and contains no instructions other than PHI nodes,
747 /// potential side-effect free intrinsics and the branch. If possible,
748 /// eliminate BB by rewriting all the predecessors to branch to the successor
749 /// block and return true. If we can't transform, return false.
751  assert(BB != &BB->getParent()->getEntryBlock() &&
752  "TryToSimplifyUncondBranchFromEmptyBlock called on entry block!");
753 
754  // We can't eliminate infinite loops.
755  BasicBlock *Succ = cast<BranchInst>(BB->getTerminator())->getSuccessor(0);
756  if (BB == Succ) return false;
757 
758  // Check to see if merging these blocks would cause conflicts for any of the
759  // phi nodes in BB or Succ. If not, we can safely merge.
760  if (!CanPropagatePredecessorsForPHIs(BB, Succ)) return false;
761 
762  // Check for cases where Succ has multiple predecessors and a PHI node in BB
763  // has uses which will not disappear when the PHI nodes are merged. It is
764  // possible to handle such cases, but difficult: it requires checking whether
765  // BB dominates Succ, which is non-trivial to calculate in the case where
766  // Succ has multiple predecessors. Also, it requires checking whether
767  // constructing the necessary self-referential PHI node doesn't introduce any
768  // conflicts; this isn't too difficult, but the previous code for doing this
769  // was incorrect.
770  //
771  // Note that if this check finds a live use, BB dominates Succ, so BB is
772  // something like a loop pre-header (or rarely, a part of an irreducible CFG);
773  // folding the branch isn't profitable in that case anyway.
774  if (!Succ->getSinglePredecessor()) {
775  BasicBlock::iterator BBI = BB->begin();
776  while (isa<PHINode>(*BBI)) {
777  for (Use &U : BBI->uses()) {
778  if (PHINode* PN = dyn_cast<PHINode>(U.getUser())) {
779  if (PN->getIncomingBlock(U) != BB)
780  return false;
781  } else {
782  return false;
783  }
784  }
785  ++BBI;
786  }
787  }
788 
789  DEBUG(dbgs() << "Killing Trivial BB: \n" << *BB);
790 
791  if (isa<PHINode>(Succ->begin())) {
792  // If there is more than one pred of succ, and there are PHI nodes in
793  // the successor, then we need to add incoming edges for the PHI nodes
794  //
795  const PredBlockVector BBPreds(pred_begin(BB), pred_end(BB));
796 
797  // Loop over all of the PHI nodes in the successor of BB.
798  for (BasicBlock::iterator I = Succ->begin(); isa<PHINode>(I); ++I) {
799  PHINode *PN = cast<PHINode>(I);
800 
801  redirectValuesFromPredecessorsToPhi(BB, BBPreds, PN);
802  }
803  }
804 
805  if (Succ->getSinglePredecessor()) {
806  // BB is the only predecessor of Succ, so Succ will end up with exactly
807  // the same predecessors BB had.
808 
809  // Copy over any phi, debug or lifetime instruction.
811  Succ->getInstList().splice(Succ->getFirstNonPHI(), BB->getInstList());
812  } else {
813  while (PHINode *PN = dyn_cast<PHINode>(&BB->front())) {
814  // We explicitly check for such uses in CanPropagatePredecessorsForPHIs.
815  assert(PN->use_empty() && "There shouldn't be any uses here!");
816  PN->eraseFromParent();
817  }
818  }
819 
820  // Everything that jumped to BB now goes to Succ.
821  BB->replaceAllUsesWith(Succ);
822  if (!Succ->hasName()) Succ->takeName(BB);
823  BB->eraseFromParent(); // Delete the old basic block.
824  return true;
825 }
826 
827 /// EliminateDuplicatePHINodes - Check for and eliminate duplicate PHI
828 /// nodes in this block. This doesn't try to be clever about PHI nodes
829 /// which differ only in the order of the incoming values, but instcombine
830 /// orders them so it usually won't matter.
831 ///
833  // This implementation doesn't currently consider undef operands
834  // specially. Theoretically, two phis which are identical except for
835  // one having an undef where the other doesn't could be collapsed.
836 
837  struct PHIDenseMapInfo {
838  static PHINode *getEmptyKey() {
840  }
841  static PHINode *getTombstoneKey() {
843  }
844  static unsigned getHashValue(PHINode *PN) {
845  // Compute a hash value on the operands. Instcombine will likely have
846  // sorted them, which helps expose duplicates, but we have to check all
847  // the operands to be safe in case instcombine hasn't run.
848  return static_cast<unsigned>(hash_combine(
850  hash_combine_range(PN->block_begin(), PN->block_end())));
851  }
852  static bool isEqual(PHINode *LHS, PHINode *RHS) {
853  if (LHS == getEmptyKey() || LHS == getTombstoneKey() ||
854  RHS == getEmptyKey() || RHS == getTombstoneKey())
855  return LHS == RHS;
856  return LHS->isIdenticalTo(RHS);
857  }
858  };
859 
860  // Set of unique PHINodes.
862 
863  // Examine each PHI.
864  bool Changed = false;
865  for (auto I = BB->begin(); PHINode *PN = dyn_cast<PHINode>(I++);) {
866  auto Inserted = PHISet.insert(PN);
867  if (!Inserted.second) {
868  // A duplicate. Replace this PHI with its duplicate.
869  PN->replaceAllUsesWith(*Inserted.first);
870  PN->eraseFromParent();
871  Changed = true;
872  }
873  }
874 
875  return Changed;
876 }
877 
878 /// enforceKnownAlignment - If the specified pointer points to an object that
879 /// we control, modify the object's alignment to PrefAlign. This isn't
880 /// often possible though. If alignment is important, a more reliable approach
881 /// is to simply align all global variables and allocation instructions to
882 /// their preferred alignment from the beginning.
883 ///
884 static unsigned enforceKnownAlignment(Value *V, unsigned Align,
885  unsigned PrefAlign,
886  const DataLayout &DL) {
887  V = V->stripPointerCasts();
888 
889  if (AllocaInst *AI = dyn_cast<AllocaInst>(V)) {
890  // If the preferred alignment is greater than the natural stack alignment
891  // then don't round up. This avoids dynamic stack realignment.
892  if (DL.exceedsNaturalStackAlignment(PrefAlign))
893  return Align;
894  // If there is a requested alignment and if this is an alloca, round up.
895  if (AI->getAlignment() >= PrefAlign)
896  return AI->getAlignment();
897  AI->setAlignment(PrefAlign);
898  return PrefAlign;
899  }
900 
901  if (auto *GO = dyn_cast<GlobalObject>(V)) {
902  // If there is a large requested alignment and we can, bump up the alignment
903  // of the global. If the memory we set aside for the global may not be the
904  // memory used by the final program then it is impossible for us to reliably
905  // enforce the preferred alignment.
906  if (!GO->isStrongDefinitionForLinker())
907  return Align;
908 
909  if (GO->getAlignment() >= PrefAlign)
910  return GO->getAlignment();
911  // We can only increase the alignment of the global if it has no alignment
912  // specified or if it is not assigned a section. If it is assigned a
913  // section, the global could be densely packed with other objects in the
914  // section, increasing the alignment could cause padding issues.
915  if (!GO->hasSection() || GO->getAlignment() == 0)
916  GO->setAlignment(PrefAlign);
917  return GO->getAlignment();
918  }
919 
920  return Align;
921 }
922 
923 /// getOrEnforceKnownAlignment - If the specified pointer has an alignment that
924 /// we can determine, return it, otherwise return 0. If PrefAlign is specified,
925 /// and it is more than the alignment of the ultimate object, see if we can
926 /// increase the alignment of the ultimate object, making this check succeed.
927 unsigned llvm::getOrEnforceKnownAlignment(Value *V, unsigned PrefAlign,
928  const DataLayout &DL,
929  const Instruction *CxtI,
930  AssumptionCache *AC,
931  const DominatorTree *DT) {
932  assert(V->getType()->isPointerTy() &&
933  "getOrEnforceKnownAlignment expects a pointer!");
934  unsigned BitWidth = DL.getPointerTypeSizeInBits(V->getType());
935 
936  APInt KnownZero(BitWidth, 0), KnownOne(BitWidth, 0);
937  computeKnownBits(V, KnownZero, KnownOne, DL, 0, AC, CxtI, DT);
938  unsigned TrailZ = KnownZero.countTrailingOnes();
939 
940  // Avoid trouble with ridiculously large TrailZ values, such as
941  // those computed from a null pointer.
942  TrailZ = std::min(TrailZ, unsigned(sizeof(unsigned) * CHAR_BIT - 1));
943 
944  unsigned Align = 1u << std::min(BitWidth - 1, TrailZ);
945 
946  // LLVM doesn't support alignments larger than this currently.
947  Align = std::min(Align, +Value::MaximumAlignment);
948 
949  if (PrefAlign > Align)
950  Align = enforceKnownAlignment(V, Align, PrefAlign, DL);
951 
952  // We don't need to make any adjustment.
953  return Align;
954 }
955 
956 ///===---------------------------------------------------------------------===//
957 /// Dbg Intrinsic utilities
958 ///
959 
960 /// See if there is a dbg.value intrinsic for DIVar before I.
961 static bool LdStHasDebugValue(const DILocalVariable *DIVar, Instruction *I) {
962  // Since we can't guarantee that the original dbg.declare instrinsic
963  // is removed by LowerDbgDeclare(), we need to make sure that we are
964  // not inserting the same dbg.value intrinsic over and over.
966  if (PrevI != I->getParent()->getInstList().begin()) {
967  --PrevI;
968  if (DbgValueInst *DVI = dyn_cast<DbgValueInst>(PrevI))
969  if (DVI->getValue() == I->getOperand(0) &&
970  DVI->getOffset() == 0 &&
971  DVI->getVariable() == DIVar)
972  return true;
973  }
974  return false;
975 }
976 
977 /// Inserts a llvm.dbg.value intrinsic before a store to an alloca'd value
978 /// that has an associated llvm.dbg.decl intrinsic.
980  StoreInst *SI, DIBuilder &Builder) {
981  auto *DIVar = DDI->getVariable();
982  auto *DIExpr = DDI->getExpression();
983  assert(DIVar && "Missing variable");
984 
985  if (LdStHasDebugValue(DIVar, SI))
986  return true;
987 
988  // If an argument is zero extended then use argument directly. The ZExt
989  // may be zapped by an optimization pass in future.
990  Argument *ExtendedArg = nullptr;
991  if (ZExtInst *ZExt = dyn_cast<ZExtInst>(SI->getOperand(0)))
992  ExtendedArg = dyn_cast<Argument>(ZExt->getOperand(0));
993  if (SExtInst *SExt = dyn_cast<SExtInst>(SI->getOperand(0)))
994  ExtendedArg = dyn_cast<Argument>(SExt->getOperand(0));
995  if (ExtendedArg)
996  Builder.insertDbgValueIntrinsic(ExtendedArg, 0, DIVar, DIExpr,
997  DDI->getDebugLoc(), SI);
998  else
999  Builder.insertDbgValueIntrinsic(SI->getOperand(0), 0, DIVar, DIExpr,
1000  DDI->getDebugLoc(), SI);
1001  return true;
1002 }
1003 
1004 /// Inserts a llvm.dbg.value intrinsic before a load of an alloca'd value
1005 /// that has an associated llvm.dbg.decl intrinsic.
1007  LoadInst *LI, DIBuilder &Builder) {
1008  auto *DIVar = DDI->getVariable();
1009  auto *DIExpr = DDI->getExpression();
1010  assert(DIVar && "Missing variable");
1011 
1012  if (LdStHasDebugValue(DIVar, LI))
1013  return true;
1014 
1015  Builder.insertDbgValueIntrinsic(LI->getOperand(0), 0, DIVar, DIExpr,
1016  DDI->getDebugLoc(), LI);
1017  return true;
1018 }
1019 
1020 /// Determine whether this alloca is either a VLA or an array.
1021 static bool isArray(AllocaInst *AI) {
1022  return AI->isArrayAllocation() ||
1023  AI->getType()->getElementType()->isArrayTy();
1024 }
1025 
1026 /// LowerDbgDeclare - Lowers llvm.dbg.declare intrinsics into appropriate set
1027 /// of llvm.dbg.value intrinsics.
1029  DIBuilder DIB(*F.getParent(), /*AllowUnresolved*/ false);
1031  for (auto &FI : F)
1032  for (BasicBlock::iterator BI : FI)
1033  if (auto DDI = dyn_cast<DbgDeclareInst>(BI))
1034  Dbgs.push_back(DDI);
1035 
1036  if (Dbgs.empty())
1037  return false;
1038 
1039  for (auto &I : Dbgs) {
1040  DbgDeclareInst *DDI = I;
1041  AllocaInst *AI = dyn_cast_or_null<AllocaInst>(DDI->getAddress());
1042  // If this is an alloca for a scalar variable, insert a dbg.value
1043  // at each load and store to the alloca and erase the dbg.declare.
1044  // The dbg.values allow tracking a variable even if it is not
1045  // stored on the stack, while the dbg.declare can only describe
1046  // the stack slot (and at a lexical-scope granularity). Later
1047  // passes will attempt to elide the stack slot.
1048  if (AI && !isArray(AI)) {
1049  for (User *U : AI->users())
1050  if (StoreInst *SI = dyn_cast<StoreInst>(U))
1052  else if (LoadInst *LI = dyn_cast<LoadInst>(U))
1053  ConvertDebugDeclareToDebugValue(DDI, LI, DIB);
1054  else if (CallInst *CI = dyn_cast<CallInst>(U)) {
1055  // This is a call by-value or some other instruction that
1056  // takes a pointer to the variable. Insert a *value*
1057  // intrinsic that describes the alloca.
1058  DIB.insertDbgValueIntrinsic(AI, 0, DDI->getVariable(),
1059  DDI->getExpression(), DDI->getDebugLoc(),
1060  CI);
1061  }
1062  DDI->eraseFromParent();
1063  }
1064  }
1065  return true;
1066 }
1067 
1068 /// FindAllocaDbgDeclare - Finds the llvm.dbg.declare intrinsic describing the
1069 /// alloca 'V', if any.
1071  if (auto *L = LocalAsMetadata::getIfExists(V))
1072  if (auto *MDV = MetadataAsValue::getIfExists(V->getContext(), L))
1073  for (User *U : MDV->users())
1074  if (DbgDeclareInst *DDI = dyn_cast<DbgDeclareInst>(U))
1075  return DDI;
1076 
1077  return nullptr;
1078 }
1079 
1081  DIBuilder &Builder, bool Deref) {
1083  if (!DDI)
1084  return false;
1085  DebugLoc Loc = DDI->getDebugLoc();
1086  auto *DIVar = DDI->getVariable();
1087  auto *DIExpr = DDI->getExpression();
1088  assert(DIVar && "Missing variable");
1089 
1090  if (Deref) {
1091  // Create a copy of the original DIDescriptor for user variable, prepending
1092  // "deref" operation to a list of address elements, as new llvm.dbg.declare
1093  // will take a value storing address of the memory for variable, not
1094  // alloca itself.
1095  SmallVector<uint64_t, 4> NewDIExpr;
1096  NewDIExpr.push_back(dwarf::DW_OP_deref);
1097  if (DIExpr)
1098  NewDIExpr.append(DIExpr->elements_begin(), DIExpr->elements_end());
1099  DIExpr = Builder.createExpression(NewDIExpr);
1100  }
1101 
1102  // Insert llvm.dbg.declare in the same basic block as the original alloca,
1103  // and remove old llvm.dbg.declare.
1104  BasicBlock *BB = AI->getParent();
1105  Builder.insertDeclare(NewAllocaAddress, DIVar, DIExpr, Loc, BB);
1106  DDI->eraseFromParent();
1107  return true;
1108 }
1109 
1110 /// changeToUnreachable - Insert an unreachable instruction before the specified
1111 /// instruction, making it and the rest of the code in the block dead.
1112 static void changeToUnreachable(Instruction *I, bool UseLLVMTrap) {
1113  BasicBlock *BB = I->getParent();
1114  // Loop over all of the successors, removing BB's entry from any PHI
1115  // nodes.
1116  for (succ_iterator SI = succ_begin(BB), SE = succ_end(BB); SI != SE; ++SI)
1117  (*SI)->removePredecessor(BB);
1118 
1119  // Insert a call to llvm.trap right before this. This turns the undefined
1120  // behavior into a hard fail instead of falling through into random code.
1121  if (UseLLVMTrap) {
1122  Function *TrapFn =
1123  Intrinsic::getDeclaration(BB->getParent()->getParent(), Intrinsic::trap);
1124  CallInst *CallTrap = CallInst::Create(TrapFn, "", I);
1125  CallTrap->setDebugLoc(I->getDebugLoc());
1126  }
1127  new UnreachableInst(I->getContext(), I);
1128 
1129  // All instructions after this are dead.
1130  BasicBlock::iterator BBI = I, BBE = BB->end();
1131  while (BBI != BBE) {
1132  if (!BBI->use_empty())
1133  BBI->replaceAllUsesWith(UndefValue::get(BBI->getType()));
1134  BB->getInstList().erase(BBI++);
1135  }
1136 }
1137 
1138 /// changeToCall - Convert the specified invoke into a normal call.
1139 static void changeToCall(InvokeInst *II) {
1140  SmallVector<Value*, 8> Args(II->op_begin(), II->op_end() - 3);
1141  CallInst *NewCall = CallInst::Create(II->getCalledValue(), Args, "", II);
1142  NewCall->takeName(II);
1143  NewCall->setCallingConv(II->getCallingConv());
1144  NewCall->setAttributes(II->getAttributes());
1145  NewCall->setDebugLoc(II->getDebugLoc());
1146  II->replaceAllUsesWith(NewCall);
1147 
1148  // Follow the call by a branch to the normal destination.
1149  BranchInst::Create(II->getNormalDest(), II);
1150 
1151  // Update PHI nodes in the unwind destination
1153  II->eraseFromParent();
1154 }
1155 
1157  SmallPtrSetImpl<BasicBlock*> &Reachable) {
1158 
1160  BasicBlock *BB = F.begin();
1161  Worklist.push_back(BB);
1162  Reachable.insert(BB);
1163  bool Changed = false;
1164  do {
1165  BB = Worklist.pop_back_val();
1166 
1167  // Do a quick scan of the basic block, turning any obviously unreachable
1168  // instructions into LLVM unreachable insts. The instruction combining pass
1169  // canonicalizes unreachable insts into stores to null or undef.
1170  for (BasicBlock::iterator BBI = BB->begin(), E = BB->end(); BBI != E;++BBI){
1171  // Assumptions that are known to be false are equivalent to unreachable.
1172  // Also, if the condition is undefined, then we make the choice most
1173  // beneficial to the optimizer, and choose that to also be unreachable.
1174  if (IntrinsicInst *II = dyn_cast<IntrinsicInst>(BBI))
1175  if (II->getIntrinsicID() == Intrinsic::assume) {
1176  bool MakeUnreachable = false;
1177  if (isa<UndefValue>(II->getArgOperand(0)))
1178  MakeUnreachable = true;
1179  else if (ConstantInt *Cond =
1180  dyn_cast<ConstantInt>(II->getArgOperand(0)))
1181  MakeUnreachable = Cond->isZero();
1182 
1183  if (MakeUnreachable) {
1184  // Don't insert a call to llvm.trap right before the unreachable.
1185  changeToUnreachable(BBI, false);
1186  Changed = true;
1187  break;
1188  }
1189  }
1190 
1191  if (CallInst *CI = dyn_cast<CallInst>(BBI)) {
1192  if (CI->doesNotReturn()) {
1193  // If we found a call to a no-return function, insert an unreachable
1194  // instruction after it. Make sure there isn't *already* one there
1195  // though.
1196  ++BBI;
1197  if (!isa<UnreachableInst>(BBI)) {
1198  // Don't insert a call to llvm.trap right before the unreachable.
1199  changeToUnreachable(BBI, false);
1200  Changed = true;
1201  }
1202  break;
1203  }
1204  }
1205 
1206  // Store to undef and store to null are undefined and used to signal that
1207  // they should be changed to unreachable by passes that can't modify the
1208  // CFG.
1209  if (StoreInst *SI = dyn_cast<StoreInst>(BBI)) {
1210  // Don't touch volatile stores.
1211  if (SI->isVolatile()) continue;
1212 
1213  Value *Ptr = SI->getOperand(1);
1214 
1215  if (isa<UndefValue>(Ptr) ||
1216  (isa<ConstantPointerNull>(Ptr) &&
1217  SI->getPointerAddressSpace() == 0)) {
1218  changeToUnreachable(SI, true);
1219  Changed = true;
1220  break;
1221  }
1222  }
1223  }
1224 
1225  // Turn invokes that call 'nounwind' functions into ordinary calls.
1226  if (InvokeInst *II = dyn_cast<InvokeInst>(BB->getTerminator())) {
1227  Value *Callee = II->getCalledValue();
1228  if (isa<ConstantPointerNull>(Callee) || isa<UndefValue>(Callee)) {
1229  changeToUnreachable(II, true);
1230  Changed = true;
1231  } else if (II->doesNotThrow() && canSimplifyInvokeNoUnwind(&F)) {
1232  if (II->use_empty() && II->onlyReadsMemory()) {
1233  // jump to the normal destination branch.
1234  BranchInst::Create(II->getNormalDest(), II);
1235  II->getUnwindDest()->removePredecessor(II->getParent());
1236  II->eraseFromParent();
1237  } else
1238  changeToCall(II);
1239  Changed = true;
1240  }
1241  }
1242 
1243  Changed |= ConstantFoldTerminator(BB, true);
1244  for (succ_iterator SI = succ_begin(BB), SE = succ_end(BB); SI != SE; ++SI)
1245  if (Reachable.insert(*SI).second)
1246  Worklist.push_back(*SI);
1247  } while (!Worklist.empty());
1248  return Changed;
1249 }
1250 
1251 /// removeUnreachableBlocksFromFn - Remove blocks that are not reachable, even
1252 /// if they are in a dead cycle. Return true if a change was made, false
1253 /// otherwise.
1256  bool Changed = markAliveBlocks(F, Reachable);
1257 
1258  // If there are unreachable blocks in the CFG...
1259  if (Reachable.size() == F.size())
1260  return Changed;
1261 
1262  assert(Reachable.size() < F.size());
1263  NumRemoved += F.size()-Reachable.size();
1264 
1265  // Loop over all of the basic blocks that are not reachable, dropping all of
1266  // their internal references...
1267  for (Function::iterator BB = ++F.begin(), E = F.end(); BB != E; ++BB) {
1268  if (Reachable.count(BB))
1269  continue;
1270 
1271  for (succ_iterator SI = succ_begin(BB), SE = succ_end(BB); SI != SE; ++SI)
1272  if (Reachable.count(*SI))
1273  (*SI)->removePredecessor(BB);
1274  BB->dropAllReferences();
1275  }
1276 
1277  for (Function::iterator I = ++F.begin(); I != F.end();)
1278  if (!Reachable.count(I))
1279  I = F.getBasicBlockList().erase(I);
1280  else
1281  ++I;
1282 
1283  return true;
1284 }
1285 
1288  K->dropUnknownMetadata(KnownIDs);
1289  K->getAllMetadataOtherThanDebugLoc(Metadata);
1290  for (unsigned i = 0, n = Metadata.size(); i < n; ++i) {
1291  unsigned Kind = Metadata[i].first;
1292  MDNode *JMD = J->getMetadata(Kind);
1293  MDNode *KMD = Metadata[i].second;
1294 
1295  switch (Kind) {
1296  default:
1297  K->setMetadata(Kind, nullptr); // Remove unknown metadata
1298  break;
1299  case LLVMContext::MD_dbg:
1300  llvm_unreachable("getAllMetadataOtherThanDebugLoc returned a MD_dbg");
1301  case LLVMContext::MD_tbaa:
1302  K->setMetadata(Kind, MDNode::getMostGenericTBAA(JMD, KMD));
1303  break;
1305  K->setMetadata(Kind, MDNode::getMostGenericAliasScope(JMD, KMD));
1306  break;
1308  K->setMetadata(Kind, MDNode::intersect(JMD, KMD));
1309  break;
1310  case LLVMContext::MD_range:
1311  K->setMetadata(Kind, MDNode::getMostGenericRange(JMD, KMD));
1312  break;
1314  K->setMetadata(Kind, MDNode::getMostGenericFPMath(JMD, KMD));
1315  break;
1317  // Only set the !invariant.load if it is present in both instructions.
1318  K->setMetadata(Kind, JMD);
1319  break;
1321  // Only set the !nonnull if it is present in both instructions.
1322  K->setMetadata(Kind, JMD);
1323  break;
1324  }
1325  }
1326 }
1327 
1329  DominatorTree &DT,
1330  const BasicBlockEdge &Root) {
1331  assert(From->getType() == To->getType());
1332 
1333  unsigned Count = 0;
1334  for (Value::use_iterator UI = From->use_begin(), UE = From->use_end();
1335  UI != UE; ) {
1336  Use &U = *UI++;
1337  if (DT.dominates(Root, U)) {
1338  U.set(To);
1339  DEBUG(dbgs() << "Replace dominated use of '"
1340  << From->getName() << "' as "
1341  << *To << " in " << *U << "\n");
1342  ++Count;
1343  }
1344  }
1345  return Count;
1346 }
static bool markAliveBlocks(Function &F, SmallPtrSetImpl< BasicBlock * > &Reachable)
Definition: Local.cpp:1156
iplist< Instruction >::iterator eraseFromParent()
eraseFromParent - This method unlinks 'this' from the containing basic block and deletes it...
Definition: Instruction.cpp:70
use_iterator use_end()
Definition: Value.h:281
use_iterator_impl< Use > use_iterator
Definition: Value.h:277
A parsed version of the target data layout string in and methods for querying it. ...
Definition: DataLayout.h:104
ConstantIntTy * getCaseValue()
Resolves case value for current case.
void removePredecessor(BasicBlock *Pred, bool DontDeleteUselessPHIs=false)
Notify the BasicBlock that the predecessor Pred is no longer able to reach it.
Definition: BasicBlock.cpp:266
static unsigned enforceKnownAlignment(Value *V, unsigned Align, unsigned PrefAlign, const DataLayout &DL)
enforceKnownAlignment - If the specified pointer points to an object that we control, modify the object's alignment to PrefAlign.
Definition: Local.cpp:884
void addIncoming(Value *V, BasicBlock *BB)
addIncoming - Add an incoming value to the end of the PHI list
unsigned getOrEnforceKnownAlignment(Value *V, unsigned PrefAlign, const DataLayout &DL, const Instruction *CxtI=nullptr, AssumptionCache *AC=nullptr, const DominatorTree *DT=nullptr)
getOrEnforceKnownAlignment - If the specified pointer has an alignment that we can determine...
Definition: Local.cpp:927
LLVM Argument representation.
Definition: Argument.h:35
uint64_t getZExtValue() const
Get zero extended value.
Definition: APInt.h:1327
STATISTIC(NumFunctions,"Total number of functions")
static bool CanPropagatePredecessorsForPHIs(BasicBlock *BB, BasicBlock *Succ)
CanPropagatePredecessorsForPHIs - Return true if we can fold BB, an almost-empty BB ending in an unco...
Definition: Local.cpp:557
DbgDeclareInst * FindAllocaDbgDeclare(Value *V)
FindAllocaDbgDeclare - Finds the llvm.dbg.declare intrinsic corresponding to an alloca, if any.
Definition: Local.cpp:1070
iterator end()
Definition: Function.h:459
DenseSet - This implements a dense probed hash-table based set.
Definition: DenseSet.h:39
This class represents zero extension of integer types.
unsigned getNumOperands() const
Definition: User.h:138
unsigned getNumOperands() const
Return number of MDNode operands.
Definition: Metadata.h:942
unsigned getPointerTypeSizeInBits(Type *) const
Layout pointer size, in bits, based on the type.
Definition: DataLayout.cpp:602
value_op_iterator value_op_begin()
Definition: User.h:209
static MDNode * getMostGenericAliasScope(MDNode *A, MDNode *B)
Definition: Metadata.cpp:810
CallInst - This class represents a function call, abstracting a target machine's calling convention...
This file contains the declarations for metadata subclasses.
size_type count(PtrType Ptr) const
count - Return 1 if the specified pointer is in the set, 0 otherwise.
Definition: SmallPtrSet.h:276
void computeKnownBits(Value *V, APInt &KnownZero, APInt &KnownOne, const DataLayout &DL, unsigned Depth=0, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr, const DominatorTree *DT=nullptr)
Determine which bits of V are known to be either zero or one and return them in the KnownZero/KnownOn...
void MergeBasicBlockIntoOnlyPred(BasicBlock *BB, DominatorTree *DT=nullptr)
MergeBasicBlockIntoOnlyPred - BB is a block with one predecessor and its predecessor is known to have...
Definition: Local.cpp:500
bool mayHaveSideEffects() const
mayHaveSideEffects - Return true if the instruction may have side effects.
Definition: Instruction.h:387
static Constant * getIntToPtr(Constant *C, Type *Ty, bool OnlyIfReduced=false)
Definition: Constants.cpp:1822
A cache of .assume calls within a function.
value_op_iterator value_op_end()
Definition: User.h:212
const Function * getParent() const
Return the enclosing method, or null if none.
Definition: BasicBlock.h:111
static void replaceUndefValuesInPhi(PHINode *PN, const IncomingValueMap &IncomingValues)
Replace the incoming undef values to a phi with the values from a block-to-value map.
Definition: Local.cpp:668
bool SimplifyInstructionsInBlock(BasicBlock *BB, const TargetLibraryInfo *TLI=nullptr)
SimplifyInstructionsInBlock - Scan the specified basic block and try to simplify any instructions in ...
Definition: Local.cpp:422
A debug info location.
Definition: DebugLoc.h:34
const Instruction & front() const
Definition: BasicBlock.h:243
Metadata node.
Definition: Metadata.h:740
F(f)
This class represents a sign extension of integer types.
LoadInst - an instruction for reading from memory.
Definition: Instructions.h:177
iterator begin()
Definition: ilist.h:359
Value * CreateICmpEQ(Value *LHS, Value *RHS, const Twine &Name="")
Definition: IRBuilder.h:1354
void RemovePredecessorAndSimplify(BasicBlock *BB, BasicBlock *Pred)
RemovePredecessorAndSimplify - Like BasicBlock::removePredecessor, this method is called when we're a...
Definition: Local.cpp:469
BranchInst * CreateCondBr(Value *Cond, BasicBlock *True, BasicBlock *False, MDNode *BranchWeights=nullptr)
Create a conditional 'br Cond, TrueDest, FalseDest' instruction.
Definition: IRBuilder.h:622
static Value * selectIncomingValueForBlock(Value *OldVal, BasicBlock *BB, IncomingValueMap &IncomingValues)
Determines the value to use as the phi node input for a block.
Definition: Local.cpp:627
unsigned replaceDominatedUsesWith(Value *From, Value *To, DominatorTree &DT, const BasicBlockEdge &Edge)
Replace each use of 'From' with 'To' if that use is dominated by the given edge.
Definition: Local.cpp:1328
Instruction * insertDbgValueIntrinsic(llvm::Value *Val, uint64_t Offset, DILocalVariable *VarInfo, DIExpression *Expr, const DILocation *DL, BasicBlock *InsertAtEnd)
Insert a new llvm.dbg.value intrinsic call.
Definition: DIBuilder.cpp:811
op_iterator op_begin()
Definition: User.h:183
const CallInst * isFreeCall(const Value *I, const TargetLibraryInfo *TLI)
isFreeCall - Returns non-null if the value is a call to the builtin free()
StringRef getName() const
Return a constant reference to the value's name.
Definition: Value.cpp:188
block_iterator block_end()
A templated base class for SmallPtrSet which provides the typesafe interface that is common across al...
Definition: SmallPtrSet.h:242
iterator begin()
Instruction iterator methods.
Definition: BasicBlock.h:231
bool isArrayAllocation() const
isArrayAllocation - Return true if there is an allocation size parameter to the allocation instructio...
std::pair< iterator, bool > insert(const std::pair< KeyT, ValueT > &KV)
Definition: DenseMap.h:169
BlockAddress - The address of a basic block.
Definition: Constants.h:802
Value * removeIncomingValue(unsigned Idx, bool DeletePHIIfEmpty=true)
removeIncomingValue - Remove an incoming value.
bool isIdenticalTo(const Instruction *I) const
isIdenticalTo - Return true if the specified instruction is exactly identical to the current one...
static CallInst * Create(Value *Func, ArrayRef< Value * > Args, const Twine &NameStr="", Instruction *InsertBefore=nullptr)
const APInt & getValue() const
Return the constant as an APInt value reference.
Definition: Constants.h:106
T LLVM_ATTRIBUTE_UNUSED_RESULT pop_back_val()
Definition: SmallVector.h:406
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
Definition: ErrorHandling.h:98
Instruction * insertDeclare(llvm::Value *Storage, DILocalVariable *VarInfo, DIExpression *Expr, const DILocation *DL, BasicBlock *InsertAtEnd)
Insert a new llvm.dbg.declare intrinsic call.
Definition: DIBuilder.cpp:764
A Use represents the edge between a Value definition and its users.
Definition: Use.h:69
bool ConstantFoldTerminator(BasicBlock *BB, bool DeleteDeadConditions=false, const TargetLibraryInfo *TLI=nullptr)
ConstantFoldTerminator - If a terminator instruction is predicated on a constant value, convert it into an unconditional branch to the constant destination.
Definition: Local.cpp:64
This provides a uniform API for creating instructions and inserting them into a basic block: either a...
Definition: IRBuilder.h:517
const Value * getCalledValue() const
getCalledValue - Get a pointer to the function that is invoked by this instruction ...
bool hasAddressTaken() const
Returns true if there are any uses of this basic block other than direct branches, switches, etc.
Definition: BasicBlock.h:306
Number of individual test Apply this number of consecutive mutations to each input exit after the first new interesting input is found the minimized corpus is saved into the first input directory Number of jobs to run If min(jobs, NumberOfCpuCores()/2)\" is used.") FUZZER_FLAG_INT(reload
bool canSimplifyInvokeNoUnwind(const Function *F)
static const unsigned MaximumAlignment
Definition: Value.h:463
block_iterator block_begin()
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:104
user_iterator_impl< User > user_iterator
Definition: Value.h:292
static void changeToCall(InvokeInst *II)
changeToCall - Convert the specified invoke into a normal call.
Definition: Local.cpp:1139
bool LLVM_ATTRIBUTE_UNUSED_RESULT empty() const
Definition: SmallVector.h:57
Value handle that is nullable, but tries to track the Value.
Definition: ValueHandle.h:141
static bool areAllUsesEqual(Instruction *I)
areAllUsesEqual - Check whether the uses of a value are all the same.
Definition: Local.cpp:378
static MDNode * intersect(MDNode *A, MDNode *B)
Definition: Metadata.cpp:796
Function * getDeclaration(Module *M, ID id, ArrayRef< Type * > Tys=None)
Create or insert an LLVM Function declaration for an intrinsic, and return it.
Definition: Function.cpp:866
StoreInst - an instruction for storing to memory.
Definition: Instructions.h:316
void replaceAllUsesWith(Value *V)
Change all uses of this to point to a new Value.
Definition: Value.cpp:351
bool isArrayTy() const
isArrayTy - True if this is an instance of ArrayType.
Definition: Type.h:213
bool EliminateDuplicatePHINodes(BasicBlock *BB)
EliminateDuplicatePHINodes - Check for and eliminate duplicate PHI nodes in this block.
Definition: Local.cpp:832
static void gatherIncomingValuesToPhi(PHINode *PN, IncomingValueMap &IncomingValues)
Create a map from block to value for the operands of a given phi.
Definition: Local.cpp:652
iterator begin()
Definition: Function.h:457
Concrete subclass of DominatorTreeBase that is used to compute a normal dominator tree...
Definition: Dominators.h:67
Type * getElementType() const
Definition: DerivedTypes.h:323
BasicBlock * getNormalDest() const
Interval::succ_iterator succ_end(Interval *I)
Definition: Interval.h:107
unsigned getNumIncomingValues() const
getNumIncomingValues - Return the number of incoming edges
DenseMap< BasicBlock *, Value * > IncomingValueMap
Definition: Local.cpp:613
static MDNode * getMostGenericRange(MDNode *A, MDNode *B)
Definition: Metadata.cpp:872
Subclasses of this class are all able to terminate a basic block.
Definition: InstrTypes.h:35
void set(Value *Val)
Definition: Value.h:516
static MetadataAsValue * getIfExists(LLVMContext &Context, Metadata *MD)
Definition: Metadata.cpp:83
LLVM Basic Block Representation.
Definition: BasicBlock.h:65
size_type size() const
Definition: SmallPtrSet.h:79
void getAllMetadataOtherThanDebugLoc(SmallVectorImpl< std::pair< unsigned, MDNode * >> &MDs) const
getAllMetadataOtherThanDebugLoc - This does the same thing as getAllMetadata, except that it filters ...
Definition: Instruction.h:190
void eraseNode(NodeT *BB)
eraseNode - Removes a node from the dominator tree.
DIExpression * getExpression() const
Definition: IntrinsicInst.h:88
bool TryToSimplifyUncondBranchFromEmptyBlock(BasicBlock *BB)
TryToSimplifyUncondBranchFromEmptyBlock - BB is known to contain an unconditional branch...
Definition: Local.cpp:750
BranchInst - Conditional or Unconditional Branch instruction.
static BlockAddress * get(Function *F, BasicBlock *BB)
get - Return a BlockAddress for the specified function and basic block.
Definition: Constants.cpp:1496
UnreachableInst - This function has undefined behavior.
This is an important base class in LLVM.
Definition: Constant.h:41
PointerType * getType() const
getType - Overload to return most specific pointer type
Definition: Instructions.h:115
This file contains the declarations for the subclasses of Constant, which represent the different fla...
IndirectBrInst - Indirect Branch Instruction.
std::pair< iterator, bool > insert(PtrType Ptr)
Inserts Ptr if and only if there is no element in the container equal to Ptr.
Definition: SmallPtrSet.h:264
Interval::pred_iterator pred_begin(Interval *I)
pred_begin/pred_end - define methods so that Intervals may be used just like BasicBlocks can with the...
Definition: Interval.h:114
const DebugLoc & getDebugLoc() const
getDebugLoc - Return the debug location for this node as a DebugLoc.
Definition: Instruction.h:230
static bool CanMergeValues(Value *First, Value *Second)
CanMergeValues - Return true if we can choose one of these values to use in place of the other...
Definition: Local.cpp:548
op_iterator op_end()
Definition: User.h:185
BasicBlock * getIncomingBlock(unsigned i) const
getIncomingBlock - Return incoming basic block number i.
const InstListType & getInstList() const
Return the underlying instruction list container.
Definition: BasicBlock.h:252
size_t size() const
Definition: Function.h:462
Value * getOperand(unsigned i) const
Definition: User.h:118
Interval::pred_iterator pred_end(Interval *I)
Definition: Interval.h:117
static bool LdStHasDebugValue(const DILocalVariable *DIVar, Instruction *I)
===---------------------------------------------------------------——===// Dbg Intrinsic utilities ...
Definition: Local.cpp:961
static MDNode * getMostGenericTBAA(MDNode *A, MDNode *B)
void append(in_iter in_start, in_iter in_end)
Add the specified range to the end of the SmallVector.
Definition: SmallVector.h:416
bool isPointerTy() const
isPointerTy - True if this is an instance of PointerType.
Definition: Type.h:217
static UndefValue * get(Type *T)
get() - Static factory methods - Return an 'undef' object of the specified type.
Definition: Constants.cpp:1473
bool RecursivelyDeleteTriviallyDeadInstructions(Value *V, const TargetLibraryInfo *TLI=nullptr)
RecursivelyDeleteTriviallyDeadInstructions - If the specified value is a trivially dead instruction...
Definition: Local.cpp:340
LLVMContext & getContext() const
All values hold a context through their type.
Definition: Value.cpp:519
bool LowerDbgDeclare(Function &F)
LowerDbgDeclare - Lowers llvm.dbg.declare intrinsics into appropriate set of llvm.dbg.value intrinsics.
Definition: Local.cpp:1028
iterator erase(iterator where)
Definition: ilist.h:465
void setMetadata(unsigned KindID, MDNode *Node)
setMetadata - Set the metadata of the specified kind to the specified node.
Definition: Metadata.cpp:1083
CallingConv::ID getCallingConv() const
getCallingConv/setCallingConv - Get or set the calling convention of this function call...
static void redirectValuesFromPredecessorsToPhi(BasicBlock *BB, const PredBlockVector &BBPreds, PHINode *PN)
Replace a value flowing from a block to a phi with potentially multiple instances of that value flowi...
Definition: Local.cpp:690
bool recursivelySimplifyInstruction(Instruction *I, const TargetLibraryInfo *TLI=nullptr, const DominatorTree *DT=nullptr, AssumptionCache *AC=nullptr)
Recursively attempt to simplify an instruction.
bool dominates(const Instruction *Def, const Use &U) const
Return true if Def dominates a use in User.
Definition: Dominators.cpp:214
static void changeToUnreachable(Instruction *I, bool UseLLVMTrap)
changeToUnreachable - Insert an unreachable instruction before the specified instruction, making it and the rest of the code in the block dead.
Definition: Local.cpp:1112
const MDOperand & getOperand(unsigned I) const
Definition: Metadata.h:936
std::pair< iterator, bool > insert(const ValueT &V)
Definition: DenseSet.h:147
void moveAfter(BasicBlock *MovePos)
Unlink this basic block from its current function and insert it right after MovePos in the function M...
Definition: BasicBlock.cpp:110
const BasicBlockListType & getBasicBlockList() const
Definition: Function.h:436
BasicBlock * getUnwindDest() const
DomTreeNodeBase< NodeT > * getIDom() const
This is the shared class of boolean and integer constants.
Definition: Constants.h:47
Value * getIncomingValue(unsigned i) const
getIncomingValue - Return incoming value number x
iterator end()
Definition: BasicBlock.h:233
bool ConvertDebugDeclareToDebugValue(DbgDeclareInst *DDI, StoreInst *SI, DIBuilder &Builder)
===---------------------------------------------------------------——===// Dbg Intrinsic utilities ...
Definition: Local.cpp:979
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:861
Type * getType() const
All values are typed, get the type of this value.
Definition: Value.h:222
Provides information about what library functions are available for the current target.
MDNode * getMetadata(unsigned KindID) const
getMetadata - Get the metadata of given kind attached to this Instruction.
Definition: Instruction.h:167
static LocalAsMetadata * getIfExists(Value *Local)
Definition: Metadata.h:346
bool RecursivelyDeleteDeadPHINode(PHINode *PN, const TargetLibraryInfo *TLI=nullptr)
RecursivelyDeleteDeadPHINode - If the specified value is an effectively 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, delete it.
Definition: Local.cpp:397
BasicBlockTy * getCaseSuccessor()
Resolves successor for current case.
Value * stripPointerCasts()
Strip off pointer casts, all-zero GEPs, and aliases.
Definition: Value.cpp:458
DIExpression * createExpression(ArrayRef< uint64_t > Addr=None)
Create a new descriptor for the specified variable which has a complex address expression for its add...
Definition: DIBuilder.cpp:616
static Constant * get(Type *Ty, uint64_t V, bool isSigned=false)
If Ty is a vector type, return a Constant with a splat of the given value.
Definition: Constants.cpp:582
static BranchInst * Create(BasicBlock *IfTrue, Instruction *InsertBefore=nullptr)
const BasicBlock & getEntryBlock() const
Definition: Function.h:442
static cl::opt< AlignMode > Align(cl::desc("Load/store alignment support"), cl::Hidden, cl::init(NoStrictAlign), cl::values(clEnumValN(StrictAlign,"aarch64-strict-align","Disallow all unaligned memory accesses"), clEnumValN(NoStrictAlign,"aarch64-no-strict-align","Allow unaligned memory accesses"), clEnumValEnd))
Value handle that asserts if the Value is deleted.
Definition: ValueHandle.h:187
SmallVector< BasicBlock *, 16 > PredBlockVector
Definition: Local.cpp:612
void splice(iterator where, iplist &L2)
Definition: ilist.h:570
void setOperand(unsigned i, Value *Val)
Definition: User.h:122
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:123
size_type count(const KeyT &Val) const
Return 1 if the specified key is in the map, 0 otherwise.
Definition: DenseMap.h:119
void swap(llvm::BitVector &LHS, llvm::BitVector &RHS)
Implement std::swap in terms of BitVector swap.
Definition: BitVector.h:576
Class for arbitrary precision integers.
Definition: APInt.h:73
hash_code hash_combine(const Ts &...args)
Combine values into a single hash_code.
Definition: Hashing.h:603
bool exceedsNaturalStackAlignment(unsigned Align) const
Returns true if the given alignment exceeds the natural stack alignment.
Definition: DataLayout.h:249
bool replaceDbgDeclareForAlloca(AllocaInst *AI, Value *NewAllocaAddress, DIBuilder &Builder, bool Deref)
Replaces llvm.dbg.declare instruction when an alloca is replaced with a new value.
Definition: Local.cpp:1080
Value * getIncomingValueForBlock(const BasicBlock *BB) const
iterator_range< user_iterator > users()
Definition: Value.h:300
BasicBlock * getSinglePredecessor()
Return the predecessor of this block if it has a single predecessor block.
Definition: BasicBlock.cpp:211
NodeT * getBlock() const
LLVM_ATTRIBUTE_UNUSED_RESULT 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:285
hash_code hash_combine_range(InputIteratorT first, InputIteratorT last)
Compute a hash_code for a sequence of values.
Definition: Hashing.h:481
use_iterator use_begin()
Definition: Value.h:279
const AttributeSet & getAttributes() const
getAttributes - Return the parameter attributes for this invoke.
static IntegerType * getInt32Ty(LLVMContext &C)
Definition: Type.cpp:239
DbgValueInst - This represents the llvm.dbg.value instruction.
iplist< BasicBlock >::iterator eraseFromParent()
Unlink 'this' from the containing function and delete it.
Definition: BasicBlock.cpp:97
#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
bool isAllocLikeFn(const Value *V, const TargetLibraryInfo *TLI, bool LookThroughBitCast=false)
Tests if a value is a call or invoke to a library function that allocates memory (either malloc...
iterator end()
Definition: DenseMap.h:68
iterator find(const KeyT &Val)
Definition: DenseMap.h:124
void destroyConstant()
Called if some element of this constant is no longer valid.
Definition: Constants.cpp:279
void dropUnknownMetadata(ArrayRef< unsigned > KnownIDs)
Drop unknown metadata.
Definition: Metadata.cpp:1048
void changeImmediateDominator(DomTreeNodeBase< NodeT > *N, DomTreeNodeBase< NodeT > *NewIDom)
changeImmediateDominator - This method is used to update the dominator tree information when a node's...
SwitchInst - Multiway switch.
static bool isArray(AllocaInst *AI)
Determine whether this alloca is either a VLA or an array.
Definition: Local.cpp:1021
bool use_empty() const
Definition: Value.h:275
DILocalVariable * getVariable() const
Definition: IntrinsicInst.h:85
user_iterator user_begin()
Definition: Value.h:294
const ARM::ArchExtKind Kind
LLVMContext & getContext() const
Get the context in which this basic block lives.
Definition: BasicBlock.cpp:32
Module * getParent()
Get the module that this global value is contained inside of...
Definition: GlobalValue.h:365
bool isInstructionTriviallyDead(Instruction *I, const TargetLibraryInfo *TLI=nullptr)
isInstructionTriviallyDead - Return true if the result produced by the instruction is not used...
Definition: Local.cpp:282
LLVM Value Representation.
Definition: Value.h:69
Value * getAddress() const
DbgDeclareInst - This represents the llvm.dbg.declare instruction.
static const Function * getParent(const Value *V)
BranchInst * CreateBr(BasicBlock *Dest)
Create an unconditional 'br label X' instruction.
Definition: IRBuilder.h:616
InvokeInst - Invoke instruction.
#define DEBUG(X)
Definition: Debug.h:92
C - The default llvm calling convention, compatible with C.
Definition: CallingConv.h:34
bool removeUnreachableBlocks(Function &F)
Remove all blocks that can not be reached from the function's entry.
Definition: Local.cpp:1254
DomTreeNodeBase< NodeT > * getNode(NodeT *BB) const
getNode - return the (Post)DominatorTree node for the specified basic block.
void setIncomingValue(unsigned i, Value *V)
static MDNode * getMostGenericFPMath(MDNode *A, MDNode *B)
Definition: Metadata.cpp:824
DbgDeclareInst - This represents the llvm.dbg.declare instruction.
Definition: IntrinsicInst.h:82
Root of the metadata hierarchy.
Definition: Metadata.h:45
void combineMetadata(Instruction *K, const Instruction *J, ArrayRef< unsigned > KnownIDs)
Combine the metadata of two instructions so that K can replace J.
Definition: Local.cpp:1286
const BasicBlock * getParent() const
Definition: Instruction.h:72
InstListType::iterator iterator
Instruction iterators...
Definition: BasicBlock.h:93
IntrinsicInst - A useful wrapper class for inspecting calls to intrinsic functions.
Definition: IntrinsicInst.h:37
AllocaInst - an instruction to allocate memory on the stack.
Definition: Instructions.h:76
user_iterator user_end()
Definition: Value.h:296